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


396055272b93adf59c7183686fc3bba414f1e9a4
[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_wxCloseEvent swig_types[23]
2486 #define SWIGTYPE_p_wxColour swig_types[24]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[25]
2488 #define SWIGTYPE_p_wxConfig swig_types[26]
2489 #define SWIGTYPE_p_wxConfigBase swig_types[27]
2490 #define SWIGTYPE_p_wxConfigPathChanger swig_types[28]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
2492 #define SWIGTYPE_p_wxControl swig_types[30]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
2494 #define SWIGTYPE_p_wxCursor swig_types[32]
2495 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
2496 #define SWIGTYPE_p_wxDC swig_types[34]
2497 #define SWIGTYPE_p_wxDataFormat swig_types[35]
2498 #define SWIGTYPE_p_wxDataObject swig_types[36]
2499 #define SWIGTYPE_p_wxDataObjectComposite swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectSimple swig_types[38]
2501 #define SWIGTYPE_p_wxDateEvent swig_types[39]
2502 #define SWIGTYPE_p_wxDateSpan swig_types[40]
2503 #define SWIGTYPE_p_wxDateTime swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[42]
2505 #define SWIGTYPE_p_wxDisplay swig_types[43]
2506 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[44]
2507 #define SWIGTYPE_p_wxDropFilesEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDuplexMode swig_types[46]
2509 #define SWIGTYPE_p_wxEraseEvent swig_types[47]
2510 #define SWIGTYPE_p_wxEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvtHandler swig_types[49]
2512 #define SWIGTYPE_p_wxFSFile swig_types[50]
2513 #define SWIGTYPE_p_wxFileConfig swig_types[51]
2514 #define SWIGTYPE_p_wxFileDataObject swig_types[52]
2515 #define SWIGTYPE_p_wxFileHistory swig_types[53]
2516 #define SWIGTYPE_p_wxFileSystem swig_types[54]
2517 #define SWIGTYPE_p_wxFileType swig_types[55]
2518 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
2519 #define SWIGTYPE_p_wxFlexGridSizer swig_types[57]
2520 #define SWIGTYPE_p_wxFocusEvent swig_types[58]
2521 #define SWIGTYPE_p_wxFont swig_types[59]
2522 #define SWIGTYPE_p_wxFrame swig_types[60]
2523 #define SWIGTYPE_p_wxGBSizerItem swig_types[61]
2524 #define SWIGTYPE_p_wxGIFHandler swig_types[62]
2525 #define SWIGTYPE_p_wxGridBagSizer swig_types[63]
2526 #define SWIGTYPE_p_wxGridSizer swig_types[64]
2527 #define SWIGTYPE_p_wxICOHandler swig_types[65]
2528 #define SWIGTYPE_p_wxIcon swig_types[66]
2529 #define SWIGTYPE_p_wxIconizeEvent swig_types[67]
2530 #define SWIGTYPE_p_wxIdleEvent swig_types[68]
2531 #define SWIGTYPE_p_wxImage swig_types[69]
2532 #define SWIGTYPE_p_wxImageHandler swig_types[70]
2533 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[71]
2534 #define SWIGTYPE_p_wxInitDialogEvent swig_types[72]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[73]
2536 #define SWIGTYPE_p_wxJoystick swig_types[74]
2537 #define SWIGTYPE_p_wxJoystickEvent swig_types[75]
2538 #define SWIGTYPE_p_wxKeyEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKillError swig_types[77]
2540 #define SWIGTYPE_p_wxLayoutConstraints swig_types[78]
2541 #define SWIGTYPE_p_wxLog swig_types[79]
2542 #define SWIGTYPE_p_wxLogBuffer swig_types[80]
2543 #define SWIGTYPE_p_wxLogChain swig_types[81]
2544 #define SWIGTYPE_p_wxLogGui swig_types[82]
2545 #define SWIGTYPE_p_wxLogNull swig_types[83]
2546 #define SWIGTYPE_p_wxLogStderr swig_types[84]
2547 #define SWIGTYPE_p_wxLogTextCtrl swig_types[85]
2548 #define SWIGTYPE_p_wxLogWindow swig_types[86]
2549 #define SWIGTYPE_p_wxMaximizeEvent swig_types[87]
2550 #define SWIGTYPE_p_wxMemorySize swig_types[88]
2551 #define SWIGTYPE_p_wxMenu swig_types[89]
2552 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2553 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2554 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2555 #define SWIGTYPE_p_wxMetafileDataObject swig_types[93]
2556 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
2557 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
2558 #define SWIGTYPE_p_wxMouseEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseState swig_types[97]
2560 #define SWIGTYPE_p_wxMoveEvent swig_types[98]
2561 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[99]
2562 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
2563 #define SWIGTYPE_p_wxNcPaintEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNotifyEvent swig_types[102]
2565 #define SWIGTYPE_p_wxObject swig_types[103]
2566 #define SWIGTYPE_p_wxOutputStream swig_types[104]
2567 #define SWIGTYPE_p_wxPCXHandler swig_types[105]
2568 #define SWIGTYPE_p_wxPNGHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNMHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPaintEvent swig_types[108]
2571 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaperSize swig_types[110]
2573 #define SWIGTYPE_p_wxPoint swig_types[111]
2574 #define SWIGTYPE_p_wxProcessEvent swig_types[112]
2575 #define SWIGTYPE_p_wxPyApp swig_types[113]
2576 #define SWIGTYPE_p_wxPyArtProvider swig_types[114]
2577 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[115]
2578 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
2579 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[117]
2580 #define SWIGTYPE_p_wxPyDropSource swig_types[118]
2581 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
2582 #define SWIGTYPE_p_wxPyEvent swig_types[120]
2583 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[121]
2584 #define SWIGTYPE_p_wxPyImageHandler swig_types[122]
2585 #define SWIGTYPE_p_wxPyLog swig_types[123]
2586 #define SWIGTYPE_p_wxPyProcess swig_types[124]
2587 #define SWIGTYPE_p_wxPySizer swig_types[125]
2588 #define SWIGTYPE_p_wxPyTextDataObject swig_types[126]
2589 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[127]
2590 #define SWIGTYPE_p_wxPyTimer swig_types[128]
2591 #define SWIGTYPE_p_wxPyTipProvider swig_types[129]
2592 #define SWIGTYPE_p_wxPyValidator swig_types[130]
2593 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[131]
2594 #define SWIGTYPE_p_wxRect swig_types[132]
2595 #define SWIGTYPE_p_wxScrollEvent swig_types[133]
2596 #define SWIGTYPE_p_wxScrollWinEvent swig_types[134]
2597 #define SWIGTYPE_p_wxSetCursorEvent swig_types[135]
2598 #define SWIGTYPE_p_wxShowEvent swig_types[136]
2599 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[137]
2600 #define SWIGTYPE_p_wxSize swig_types[138]
2601 #define SWIGTYPE_p_wxSizeEvent swig_types[139]
2602 #define SWIGTYPE_p_wxSizer swig_types[140]
2603 #define SWIGTYPE_p_wxSizerItem swig_types[141]
2604 #define SWIGTYPE_p_wxSound swig_types[142]
2605 #define SWIGTYPE_p_wxStandardPaths swig_types[143]
2606 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[144]
2607 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[145]
2608 #define SWIGTYPE_p_wxStopWatch swig_types[146]
2609 #define SWIGTYPE_p_wxString swig_types[147]
2610 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[148]
2611 #define SWIGTYPE_p_wxSystemOptions swig_types[149]
2612 #define SWIGTYPE_p_wxSystemSettings swig_types[150]
2613 #define SWIGTYPE_p_wxTIFFHandler swig_types[151]
2614 #define SWIGTYPE_p_wxTextCtrl swig_types[152]
2615 #define SWIGTYPE_p_wxTextDataObject swig_types[153]
2616 #define SWIGTYPE_p_wxTimeSpan swig_types[154]
2617 #define SWIGTYPE_p_wxTimer swig_types[155]
2618 #define SWIGTYPE_p_wxTimerEvent swig_types[156]
2619 #define SWIGTYPE_p_wxTimerRunner swig_types[157]
2620 #define SWIGTYPE_p_wxTipProvider swig_types[158]
2621 #define SWIGTYPE_p_wxToolTip swig_types[159]
2622 #define SWIGTYPE_p_wxURLDataObject swig_types[160]
2623 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[161]
2624 #define SWIGTYPE_p_wxValidator swig_types[162]
2625 #define SWIGTYPE_p_wxVideoMode swig_types[163]
2626 #define SWIGTYPE_p_wxWindow swig_types[164]
2627 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[165]
2628 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[166]
2629 #define SWIGTYPE_p_wxWindowDisabler swig_types[167]
2630 #define SWIGTYPE_p_wxXPMHandler swig_types[168]
2631 static swig_type_info *swig_types[170];
2632 static swig_module_info swig_module = {swig_types, 169, 0, 0, 0, 0};
2633 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2634 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2635
2636 /* -------- TYPES TABLE (END) -------- */
2637
2638 #if (PY_VERSION_HEX <= 0x02000000)
2639 # if !defined(SWIG_PYTHON_CLASSIC)
2640 # error "This python version requires to use swig with the '-classic' option"
2641 # endif
2642 #endif
2643 #if (PY_VERSION_HEX <= 0x02020000)
2644 # error "This python version requires to use swig with the '-nomodern' option"
2645 #endif
2646 #if (PY_VERSION_HEX <= 0x02020000)
2647 # error "This python version requires to use swig with the '-nomodernargs' option"
2648 #endif
2649 #ifndef METH_O
2650 # error "This python version requires to use swig with the '-nofastunpack' option"
2651 #endif
2652
2653 /*-----------------------------------------------
2654 @(target):= _misc_.so
2655 ------------------------------------------------*/
2656 #define SWIG_init init_misc_
2657
2658 #define SWIG_name "_misc_"
2659
2660 #define SWIGVERSION 0x010329
2661
2662
2663 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2664 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2665
2666
2667 #include <stdexcept>
2668
2669
2670 namespace swig {
2671 class PyObject_ptr {
2672 protected:
2673 PyObject *_obj;
2674
2675 public:
2676 PyObject_ptr() :_obj(0)
2677 {
2678 }
2679
2680 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2681 {
2682 Py_XINCREF(_obj);
2683 }
2684
2685 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2686 {
2687 if (initial_ref) Py_XINCREF(_obj);
2688 }
2689
2690 PyObject_ptr & operator=(const PyObject_ptr& item)
2691 {
2692 Py_XINCREF(item._obj);
2693 Py_XDECREF(_obj);
2694 _obj = item._obj;
2695 return *this;
2696 }
2697
2698 ~PyObject_ptr()
2699 {
2700 Py_XDECREF(_obj);
2701 }
2702
2703 operator PyObject *() const
2704 {
2705 return _obj;
2706 }
2707
2708 PyObject *operator->() const
2709 {
2710 return _obj;
2711 }
2712 };
2713 }
2714
2715
2716 namespace swig {
2717 struct PyObject_var : PyObject_ptr {
2718 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2719
2720 PyObject_var & operator = (PyObject* obj)
2721 {
2722 Py_XDECREF(_obj);
2723 _obj = obj;
2724 return *this;
2725 }
2726 };
2727 }
2728
2729
2730 #include "wx/wxPython/wxPython.h"
2731 #include "wx/wxPython/pyclasses.h"
2732 #include "wx/wxPython/pyistream.h"
2733
2734 static const wxString wxPyEmptyString(wxEmptyString);
2735
2736
2737
2738 #define SWIG_From_long PyInt_FromLong
2739
2740
2741 SWIGINTERNINLINE PyObject *
2742 SWIG_From_int (int value)
2743 {
2744 return SWIG_From_long (value);
2745 }
2746
2747
2748 #include <limits.h>
2749 #ifndef LLONG_MIN
2750 # define LLONG_MIN LONG_LONG_MIN
2751 #endif
2752 #ifndef LLONG_MAX
2753 # define LLONG_MAX LONG_LONG_MAX
2754 #endif
2755 #ifndef ULLONG_MAX
2756 # define ULLONG_MAX ULONG_LONG_MAX
2757 #endif
2758
2759
2760 SWIGINTERN int
2761 SWIG_AsVal_long (PyObject* obj, long* val)
2762 {
2763 if (PyNumber_Check(obj)) {
2764 if (val) *val = PyInt_AsLong(obj);
2765 return SWIG_OK;
2766 }
2767 return SWIG_TypeError;
2768 }
2769
2770
2771 SWIGINTERN int
2772 SWIG_AsVal_int (PyObject * obj, int *val)
2773 {
2774 long v;
2775 int res = SWIG_AsVal_long (obj, &v);
2776 if (SWIG_IsOK(res)) {
2777 if ((v < INT_MIN || v > INT_MAX)) {
2778 return SWIG_OverflowError;
2779 } else {
2780 if (val) *val = static_cast< int >(v);
2781 }
2782 }
2783 return res;
2784 }
2785
2786 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2787
2788 #include <wx/stockitem.h>
2789
2790 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2791 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2792 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2793
2794 SWIGINTERN int
2795 SWIG_AsVal_bool (PyObject *obj, bool *val)
2796 {
2797 if (obj == Py_True) {
2798 if (val) *val = true;
2799 return SWIG_OK;
2800 } else if (obj == Py_False) {
2801 if (val) *val = false;
2802 return SWIG_OK;
2803 } else {
2804 long v = 0;
2805 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2806 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2807 return res;
2808 }
2809 }
2810
2811
2812 wxMemorySize wxGetFreeMemory()
2813 { wxPyRaiseNotImplemented(); return 0; }
2814
2815
2816 SWIGINTERN int
2817 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2818 {
2819 long v = 0;
2820 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2821 return SWIG_TypeError;
2822 }
2823 else if (val)
2824 *val = (unsigned long)v;
2825 return SWIG_OK;
2826 }
2827
2828
2829 SWIGINTERNINLINE PyObject*
2830 SWIG_From_unsigned_SS_long (unsigned long value)
2831 {
2832 return (value > LONG_MAX) ?
2833 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2834 }
2835
2836
2837 void* wxGetXDisplay()
2838 {
2839 #ifdef __WXGTK__
2840 return wxGetDisplay();
2841 #else
2842 return NULL;
2843 #endif
2844 }
2845
2846
2847 wxWindow* FindWindowAtPointer() {
2848 wxPoint unused;
2849 return wxFindWindowAtPointer(unused);
2850 }
2851
2852
2853 void wxWakeUpMainThread() {}
2854
2855
2856 bool wxThread_IsMain() {
2857 #ifdef WXP_WITH_THREAD
2858 return wxThread::IsMain();
2859 #else
2860 return true;
2861 #endif
2862 }
2863
2864 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2865 delete self;
2866 }
2867
2868 #include <wx/snglinst.h>
2869
2870
2871 #ifdef __WXMSW__
2872 #include <wx/msw/private.h>
2873 #include <wx/dynload.h>
2874 #endif
2875
2876
2877
2878 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2879 #if 0
2880 , int method
2881 #endif
2882 )
2883 {
2884 #ifdef __WXMSW__
2885 #if 0
2886 switch (method)
2887 {
2888 case 1:
2889 // This one only partially works. Appears to be an undocumented
2890 // "standard" convention that not all widgets adhear to. For
2891 // example, for some widgets backgrounds or non-client areas may
2892 // not be painted.
2893 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2894 break;
2895
2896 case 2:
2897 #endif
2898 // This one works much better, nearly all widgets and their
2899 // children are captured correctly[**]. Prior to the big
2900 // background erase changes that Vadim did in 2004-2005 this
2901 // method failed badly on XP with Themes activated, most native
2902 // widgets draw only partially, if at all. Without themes it
2903 // worked just like on Win2k. After those changes this method
2904 // works very well.
2905 //
2906 // ** For example the radio buttons in a wxRadioBox are not its
2907 // children by default, but you can capture it via the panel
2908 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2909 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2910 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2911 PRF_ERASEBKGND | PRF_OWNED );
2912 return true;
2913 #if 0
2914 break;
2915
2916 case 3:
2917 // This one is only defined in the latest SDK and is only
2918 // available on XP. MSDN says it is similar to sending WM_PRINT
2919 // so I expect that it will work similar to the above. Since it
2920 // is avaialble only on XP, it can't be compiled like this and
2921 // will have to be loaded dynamically.
2922 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2923
2924 // fall through
2925
2926 case 4:
2927 // Use PrintWindow if available, or fallback to WM_PRINT
2928 // otherwise. Unfortunately using PrintWindow is even worse than
2929 // WM_PRINT. For most native widgets nothing is drawn to the dc
2930 // at all, with or without Themes.
2931 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2932 static bool s_triedToLoad = false;
2933 static PrintWindow_t pfnPrintWindow = NULL;
2934 if ( !s_triedToLoad )
2935 {
2936
2937 s_triedToLoad = true;
2938 wxDynamicLibrary dllUser32(_T("user32.dll"));
2939 if ( dllUser32.IsLoaded() )
2940 {
2941 wxLogNull nolog; // Don't report errors here
2942 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2943 }
2944 }
2945 if (pfnPrintWindow)
2946 {
2947 //printf("Using PrintWindow\n");
2948 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2949 }
2950 else
2951 {
2952 //printf("Using WM_PRINT\n");
2953 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2954 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2955 PRF_ERASEBKGND | PRF_OWNED );
2956 }
2957 }
2958 #endif // 0
2959 #else
2960 return false;
2961 #endif // __WXMSW__
2962 }
2963
2964
2965
2966 #include <wx/tipdlg.h>
2967
2968
2969 SWIGINTERNINLINE PyObject *
2970 SWIG_From_size_t (size_t value)
2971 {
2972 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2973 }
2974
2975
2976 class wxPyTipProvider : public wxTipProvider {
2977 public:
2978 wxPyTipProvider(size_t currentTip)
2979 : wxTipProvider(currentTip) {}
2980
2981 DEC_PYCALLBACK_STRING__pure(GetTip);
2982 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2983 PYPRIVATE;
2984 };
2985
2986 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2987 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2988
2989
2990 SWIGINTERNINLINE int
2991 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2992 {
2993 unsigned long v;
2994 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2995 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2996 return res;
2997 }
2998
2999
3000 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3001
3002 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3003
3004 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3005 : wxTimer(owner, id)
3006 {
3007 if (owner == NULL)
3008 SetOwner(this);
3009 }
3010
3011
3012 SWIGINTERN swig_type_info*
3013 SWIG_pchar_descriptor()
3014 {
3015 static int init = 0;
3016 static swig_type_info* info = 0;
3017 if (!init) {
3018 info = SWIG_TypeQuery("_p_char");
3019 init = 1;
3020 }
3021 return info;
3022 }
3023
3024
3025 SWIGINTERNINLINE PyObject *
3026 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3027 {
3028 if (carray) {
3029 if (size > INT_MAX) {
3030 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3031 return pchar_descriptor ?
3032 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3033 } else {
3034 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3035 }
3036 } else {
3037 return SWIG_Py_Void();
3038 }
3039 }
3040
3041
3042 SWIGINTERNINLINE PyObject *
3043 SWIG_FromCharPtr(const char *cptr)
3044 {
3045 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3046 }
3047
3048
3049 SWIGINTERN int
3050 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3051 {
3052 unsigned long v;
3053 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3054 if (SWIG_IsOK(res)) {
3055 if ((v > UINT_MAX)) {
3056 return SWIG_OverflowError;
3057 } else {
3058 if (val) *val = static_cast< unsigned int >(v);
3059 }
3060 }
3061 return res;
3062 }
3063
3064 SWIGINTERN wxString wxLog_TimeStamp(){
3065 wxString msg;
3066 wxLog::TimeStamp(&msg);
3067 return msg;
3068 }
3069 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3070 // Make some wrappers that double any % signs so they are 'escaped'
3071 void wxPyLogFatalError(const wxString& msg)
3072 {
3073 wxString m(msg);
3074 m.Replace(wxT("%"), wxT("%%"));
3075 wxLogFatalError(m);
3076 }
3077
3078 void wxPyLogError(const wxString& msg)
3079 {
3080 wxString m(msg);
3081 m.Replace(wxT("%"), wxT("%%"));
3082 wxLogError(m);
3083 }
3084
3085 void wxPyLogWarning(const wxString& msg)
3086 {
3087 wxString m(msg);
3088 m.Replace(wxT("%"), wxT("%%"));
3089 wxLogWarning(m);
3090 }
3091
3092 void wxPyLogMessage(const wxString& msg)
3093 {
3094 wxString m(msg);
3095 m.Replace(wxT("%"), wxT("%%"));
3096 wxLogMessage(m);
3097 }
3098
3099 void wxPyLogInfo(const wxString& msg)
3100 {
3101 wxString m(msg);
3102 m.Replace(wxT("%"), wxT("%%"));
3103 wxLogInfo(m);
3104 }
3105
3106 void wxPyLogDebug(const wxString& msg)
3107 {
3108 wxString m(msg);
3109 m.Replace(wxT("%"), wxT("%%"));
3110 wxLogDebug(m);
3111 }
3112
3113 void wxPyLogVerbose(const wxString& msg)
3114 {
3115 wxString m(msg);
3116 m.Replace(wxT("%"), wxT("%%"));
3117 wxLogVerbose(m);
3118 }
3119
3120 void wxPyLogStatus(const wxString& msg)
3121 {
3122 wxString m(msg);
3123 m.Replace(wxT("%"), wxT("%%"));
3124 wxLogStatus(m);
3125 }
3126
3127 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3128 {
3129 wxString m(msg);
3130 m.Replace(wxT("%"), wxT("%%"));
3131 wxLogStatus(pFrame, m);
3132 }
3133
3134 void wxPyLogSysError(const wxString& msg)
3135 {
3136 wxString m(msg);
3137 m.Replace(wxT("%"), wxT("%%"));
3138 wxLogSysError(m);
3139 }
3140
3141 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3142 {
3143 wxString m(msg);
3144 m.Replace(wxT("%"), wxT("%%"));
3145 wxLogGeneric(level, m);
3146 }
3147
3148 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3149 {
3150 wxString m(msg);
3151 m.Replace(wxT("%"), wxT("%%"));
3152 wxLogTrace(mask, m);
3153 }
3154
3155 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3156 {
3157 wxString m(msg);
3158 m.Replace(wxT("%"), wxT("%%"));
3159 wxLogTrace(mask, m);
3160 }
3161
3162
3163
3164 // A wxLog class that can be derived from in wxPython
3165 class wxPyLog : public wxLog {
3166 public:
3167 wxPyLog() : wxLog() {}
3168
3169 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3170 bool found;
3171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3172 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3173 PyObject* s = wx2PyString(szString);
3174 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3175 Py_DECREF(s);
3176 }
3177 wxPyEndBlockThreads(blocked);
3178 if (! found)
3179 wxLog::DoLog(level, szString, t);
3180 }
3181
3182 virtual void DoLogString(const wxChar *szString, time_t t) {
3183 bool found;
3184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3185 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3186 PyObject* s = wx2PyString(szString);
3187 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3188 Py_DECREF(s);
3189 }
3190 wxPyEndBlockThreads(blocked);
3191 if (! found)
3192 wxLog::DoLogString(szString, t);
3193 }
3194
3195 DEC_PYCALLBACK_VOID_(Flush);
3196 PYPRIVATE;
3197 };
3198 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3199
3200
3201
3202
3203 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3204
3205
3206 #include <wx/joystick.h>
3207
3208
3209 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3210 // A C++ stub class for wxJoystick for platforms that don't have it.
3211 class wxJoystick : public wxObject {
3212 public:
3213 wxJoystick(int joystick = wxJOYSTICK1) {
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 PyErr_SetString(PyExc_NotImplementedError,
3216 "wxJoystick is not available on this platform.");
3217 wxPyEndBlockThreads(blocked);
3218 }
3219 wxPoint GetPosition() { return wxPoint(-1,-1); }
3220 int GetZPosition() { return -1; }
3221 int GetButtonState() { return -1; }
3222 int GetPOVPosition() { return -1; }
3223 int GetPOVCTSPosition() { return -1; }
3224 int GetRudderPosition() { return -1; }
3225 int GetUPosition() { return -1; }
3226 int GetVPosition() { return -1; }
3227 int GetMovementThreshold() { return -1; }
3228 void SetMovementThreshold(int threshold) {}
3229
3230 bool IsOk(void) { return false; }
3231 int GetNumberJoysticks() { return -1; }
3232 int GetManufacturerId() { return -1; }
3233 int GetProductId() { return -1; }
3234 wxString GetProductName() { return wxEmptyString; }
3235 int GetXMin() { return -1; }
3236 int GetYMin() { return -1; }
3237 int GetZMin() { return -1; }
3238 int GetXMax() { return -1; }
3239 int GetYMax() { return -1; }
3240 int GetZMax() { return -1; }
3241 int GetNumberButtons() { return -1; }
3242 int GetNumberAxes() { return -1; }
3243 int GetMaxButtons() { return -1; }
3244 int GetMaxAxes() { return -1; }
3245 int GetPollingMin() { return -1; }
3246 int GetPollingMax() { return -1; }
3247 int GetRudderMin() { return -1; }
3248 int GetRudderMax() { return -1; }
3249 int GetUMin() { return -1; }
3250 int GetUMax() { return -1; }
3251 int GetVMin() { return -1; }
3252 int GetVMax() { return -1; }
3253
3254 bool HasRudder() { return false; }
3255 bool HasZ() { return false; }
3256 bool HasU() { return false; }
3257 bool HasV() { return false; }
3258 bool HasPOV() { return false; }
3259 bool HasPOV4Dir() { return false; }
3260 bool HasPOVCTS() { return false; }
3261
3262 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3263 bool ReleaseCapture() { return false; }
3264 };
3265 #endif
3266
3267
3268 #include <wx/sound.h>
3269
3270
3271 #if !wxUSE_SOUND
3272 // A C++ stub class for wxWave for platforms that don't have it.
3273 class wxSound : public wxObject
3274 {
3275 public:
3276 wxSound() {
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 PyErr_SetString(PyExc_NotImplementedError,
3279 "wxSound is not available on this platform.");
3280 wxPyEndBlockThreads(blocked);
3281 }
3282 wxSound(const wxString&/*, bool*/) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288 wxSound(int, const wxByte*) {
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 PyErr_SetString(PyExc_NotImplementedError,
3291 "wxSound is not available on this platform.");
3292 wxPyEndBlockThreads(blocked);
3293 }
3294
3295 ~wxSound() {};
3296
3297 bool Create(const wxString&/*, bool*/) { return false; }
3298 bool Create(int, const wxByte*) { return false; };
3299 bool IsOk() { return false; };
3300 bool Play(unsigned) const { return false; }
3301 static bool Play(const wxString&, unsigned) { return false; }
3302 static void Stop() {}
3303 };
3304
3305 #endif
3306
3307 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3308 if (fileName.Length() == 0)
3309 return new wxSound;
3310 else
3311 return new wxSound(fileName);
3312 }
3313 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3314 unsigned char* buffer; int size;
3315 wxSound *sound = NULL;
3316
3317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3318 if (!PyArg_Parse(data, "t#", &buffer, &size))
3319 goto done;
3320 sound = new wxSound(size, buffer);
3321 done:
3322 wxPyEndBlockThreads(blocked);
3323 return sound;
3324 }
3325 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3326 #ifndef __WXMAC__
3327 unsigned char* buffer;
3328 int size;
3329 bool rv = false;
3330
3331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3332 if (!PyArg_Parse(data, "t#", &buffer, &size))
3333 goto done;
3334 rv = self->Create(size, buffer);
3335 done:
3336 wxPyEndBlockThreads(blocked);
3337 return rv;
3338 #else
3339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3340 PyErr_SetString(PyExc_NotImplementedError,
3341 "Create from data is not available on this platform.");
3342 wxPyEndBlockThreads(blocked);
3343 return false;
3344 #endif
3345 }
3346
3347 #include <wx/mimetype.h>
3348
3349 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3350 wxString str;
3351 if (self->GetMimeType(&str))
3352 return wx2PyString(str);
3353 else
3354 RETURN_NONE();
3355 }
3356 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3357 wxArrayString arr;
3358 if (self->GetMimeTypes(arr))
3359 return wxArrayString2PyList_helper(arr);
3360 else
3361 RETURN_NONE();
3362 }
3363 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3364 wxArrayString arr;
3365 if (self->GetExtensions(arr))
3366 return wxArrayString2PyList_helper(arr);
3367 else
3368 RETURN_NONE();
3369 }
3370 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3371 wxIconLocation loc;
3372 if (self->GetIcon(&loc))
3373 return new wxIcon(loc);
3374 else
3375 return NULL;
3376 }
3377 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3378 wxIconLocation loc;
3379 if (self->GetIcon(&loc)) {
3380 wxString iconFile = loc.GetFileName();
3381 int iconIndex = -1;
3382
3383
3384
3385 // Make a tuple and put the values in it
3386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3387 PyObject* tuple = PyTuple_New(3);
3388 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3389 wxT("wxIcon"), true));
3390 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3391 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3392 wxPyEndBlockThreads(blocked);
3393 return tuple;
3394 }
3395 else
3396 RETURN_NONE();
3397 }
3398 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3399 wxString str;
3400 if (self->GetDescription(&str))
3401 return wx2PyString(str);
3402 else
3403 RETURN_NONE();
3404 }
3405 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3406 wxString str;
3407 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3408 return wx2PyString(str);
3409 else
3410 RETURN_NONE();
3411 }
3412 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3413 wxString str;
3414 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3415 return wx2PyString(str);
3416 else
3417 RETURN_NONE();
3418 }
3419 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3420 wxArrayString verbs;
3421 wxArrayString commands;
3422 if (self->GetAllCommands(&verbs, &commands,
3423 wxFileType::MessageParameters(filename, mimetype))) {
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 PyObject* tuple = PyTuple_New(2);
3426 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3427 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3428 wxPyEndBlockThreads(blocked);
3429 return tuple;
3430 }
3431 else
3432 RETURN_NONE();
3433 }
3434 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3435 return wxFileType::ExpandCommand(command,
3436 wxFileType::MessageParameters(filename, mimetype));
3437 }
3438 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3439 wxArrayString arr;
3440 self->EnumAllFileTypes(arr);
3441 return wxArrayString2PyList_helper(arr);
3442 }
3443
3444 #include <wx/artprov.h>
3445
3446 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3447 static const wxString wxPyART_MENU(wxART_MENU);
3448 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3449 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3450 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3451 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3452 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3453 static const wxString wxPyART_OTHER(wxART_OTHER);
3454 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3455 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3456 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3457 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3458 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3459 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3460 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3461 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3462 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3463 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3464 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3465 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3466 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3467 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3468 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3469 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3470 static const wxString wxPyART_PRINT(wxART_PRINT);
3471 static const wxString wxPyART_HELP(wxART_HELP);
3472 static const wxString wxPyART_TIP(wxART_TIP);
3473 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3474 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3475 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3476 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3477 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3478 static const wxString wxPyART_CDROM(wxART_CDROM);
3479 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3480 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3481 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3482 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3483 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3484 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3485 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3486 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3487 static const wxString wxPyART_ERROR(wxART_ERROR);
3488 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3489 static const wxString wxPyART_WARNING(wxART_WARNING);
3490 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3491 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3492 static const wxString wxPyART_COPY(wxART_COPY);
3493 static const wxString wxPyART_CUT(wxART_CUT);
3494 static const wxString wxPyART_PASTE(wxART_PASTE);
3495 static const wxString wxPyART_DELETE(wxART_DELETE);
3496 static const wxString wxPyART_NEW(wxART_NEW);
3497 static const wxString wxPyART_UNDO(wxART_UNDO);
3498 static const wxString wxPyART_REDO(wxART_REDO);
3499 static const wxString wxPyART_QUIT(wxART_QUIT);
3500 static const wxString wxPyART_FIND(wxART_FIND);
3501 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3502 // Python aware wxArtProvider
3503 class wxPyArtProvider : public wxArtProvider {
3504 public:
3505
3506 virtual wxBitmap CreateBitmap(const wxArtID& id,
3507 const wxArtClient& client,
3508 const wxSize& size) {
3509 wxBitmap rval = wxNullBitmap;
3510 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3511 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3512 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3513 PyObject* ro;
3514 wxBitmap* ptr;
3515 PyObject* s1, *s2;
3516 s1 = wx2PyString(id);
3517 s2 = wx2PyString(client);
3518 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3519 Py_DECREF(so);
3520 Py_DECREF(s1);
3521 Py_DECREF(s2);
3522 if (ro) {
3523 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3524 rval = *ptr;
3525 Py_DECREF(ro);
3526 }
3527 }
3528 wxPyEndBlockThreads(blocked);
3529 return rval;
3530 }
3531
3532 PYPRIVATE;
3533 };
3534
3535 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3536
3537
3538
3539 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3540 PyObject* ret = PyTuple_New(3);
3541 if (ret) {
3542 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3543 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3544 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3545 }
3546 return ret;
3547 }
3548
3549 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3550 bool cont;
3551 long index = 0;
3552 wxString value;
3553
3554 cont = self->GetFirstGroup(value, index);
3555 return __EnumerationHelper(cont, value, index);
3556 }
3557 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3558 bool cont;
3559 wxString value;
3560
3561 cont = self->GetNextGroup(value, index);
3562 return __EnumerationHelper(cont, value, index);
3563 }
3564 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3565 bool cont;
3566 long index = 0;
3567 wxString value;
3568
3569 cont = self->GetFirstEntry(value, index);
3570 return __EnumerationHelper(cont, value, index);
3571 }
3572 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3573 bool cont;
3574 wxString value;
3575
3576 cont = self->GetNextEntry(value, index);
3577 return __EnumerationHelper(cont, value, index);
3578 }
3579 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3580 long rv;
3581 self->Read(key, &rv, defaultVal);
3582 return rv;
3583 }
3584
3585 SWIGINTERN int
3586 SWIG_AsVal_double (PyObject *obj, double* val)
3587 {
3588 if (PyNumber_Check(obj)) {
3589 if (val) *val = PyFloat_AsDouble(obj);
3590 return SWIG_OK;
3591 }
3592 return SWIG_TypeError;
3593 }
3594
3595 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3596 double rv;
3597 self->Read(key, &rv, defaultVal);
3598 return rv;
3599 }
3600
3601 #define SWIG_From_double PyFloat_FromDouble
3602
3603 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3604 bool rv;
3605 self->Read(key, &rv, defaultVal);
3606 return rv;
3607 }
3608
3609 #include <wx/datetime.h>
3610
3611 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3612 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3613
3614 #define LOCAL_TZ wxDateTime::Local
3615
3616 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3617 wxString am;
3618 wxString pm;
3619 wxDateTime::GetAmPmStrings(&am, &pm);
3620 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3621 PyObject* tup = PyTuple_New(2);
3622 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3623 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3624 wxPyEndBlockThreads(blocked);
3625 return tup;
3626 }
3627
3628 SWIGINTERNINLINE PyObject *
3629 SWIG_From_unsigned_SS_int (unsigned int value)
3630 {
3631 return SWIG_From_unsigned_SS_long (value);
3632 }
3633
3634 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3635 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3636 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3637 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3638 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3639 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3640 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3641 return (*self < *other);
3642 }
3643 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3644 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3645 return (*self <= *other);
3646 }
3647 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3649 return (*self > *other);
3650 }
3651 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3653 return (*self >= *other);
3654 }
3655 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3657 return (*self == *other);
3658 }
3659 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3661 return (*self != *other);
3662 }
3663 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3664 const wxChar* rv;
3665 const wxChar* _date = date;
3666 rv = self->ParseRfc822Date(_date);
3667 if (rv == NULL) return -1;
3668 return rv - _date;
3669 }
3670 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3671 const wxChar* rv;
3672 const wxChar* _date = date;
3673 rv = self->ParseFormat(_date, format, dateDef);
3674 if (rv == NULL) return -1;
3675 return rv - _date;
3676 }
3677 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3678 const wxChar* rv;
3679 const wxChar* _datetime = datetime;
3680 rv = self->ParseDateTime(_datetime);
3681 if (rv == NULL) return -1;
3682 return rv - _datetime;
3683 }
3684 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3685 const wxChar* rv;
3686 const wxChar* _date = date;
3687 rv = self->ParseDate(_date);
3688 if (rv == NULL) return -1;
3689 return rv - _date;
3690 }
3691 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3692 const wxChar* rv;
3693 const wxChar* _time = time;
3694 rv = self->ParseTime(_time);
3695 if (rv == NULL) return -1;
3696 return rv - _time;
3697 }
3698 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3699 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3700 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3702 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3703 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3704 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3705 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3706 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3708 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3709 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3710 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3711 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3712 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3713 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3714
3715 #include <wx/dataobj.h>
3716
3717 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3718 size_t count = self->GetFormatCount(dir);
3719 wxDataFormat* formats = new wxDataFormat[count];
3720 self->GetAllFormats(formats, dir);
3721
3722 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3723 PyObject* list = PyList_New(count);
3724 for (size_t i=0; i<count; i++) {
3725 wxDataFormat* format = new wxDataFormat(formats[i]);
3726 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3727 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3728 }
3729 wxPyEndBlockThreads(blocked);
3730 delete [] formats;
3731 return list;
3732 }
3733 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3734 PyObject* rval = NULL;
3735 size_t size = self->GetDataSize(format);
3736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3737 if (size) {
3738 char* buf = new char[size];
3739 if (self->GetDataHere(format, buf))
3740 rval = PyString_FromStringAndSize(buf, size);
3741 delete [] buf;
3742 }
3743 if (! rval) {
3744 rval = Py_None;
3745 Py_INCREF(rval);
3746 }
3747 wxPyEndBlockThreads(blocked);
3748 return rval;
3749 }
3750 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3751 bool rval;
3752 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3753 if (PyString_Check(data)) {
3754 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3755 }
3756 else {
3757 // raise a TypeError if not a string
3758 PyErr_SetString(PyExc_TypeError, "String expected.");
3759 rval = false;
3760 }
3761 wxPyEndBlockThreads(blocked);
3762 return rval;
3763 }
3764 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3765 PyObject* rval = NULL;
3766 size_t size = self->GetDataSize();
3767 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3768 if (size) {
3769 char* buf = new char[size];
3770 if (self->GetDataHere(buf))
3771 rval = PyString_FromStringAndSize(buf, size);
3772 delete [] buf;
3773 }
3774 if (! rval) {
3775 rval = Py_None;
3776 Py_INCREF(rval);
3777 }
3778 wxPyEndBlockThreads(blocked);
3779 return rval;
3780 }
3781 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3782 bool rval;
3783 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3784 if (PyString_Check(data)) {
3785 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3786 }
3787 else {
3788 // raise a TypeError if not a string
3789 PyErr_SetString(PyExc_TypeError, "String expected.");
3790 rval = false;
3791 }
3792 wxPyEndBlockThreads(blocked);
3793 return rval;
3794 }
3795 // Create a new class for wxPython to use
3796 class wxPyDataObjectSimple : public wxDataObjectSimple {
3797 public:
3798 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3799 : wxDataObjectSimple(format) {}
3800
3801 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3802 bool GetDataHere(void *buf) const;
3803 bool SetData(size_t len, const void *buf) const;
3804 PYPRIVATE;
3805 };
3806
3807 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3808
3809 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3810 // We need to get the data for this object and write it to buf. I think
3811 // the best way to do this for wxPython is to have the Python method
3812 // return either a string or None and then act appropriately with the
3813 // C++ version.
3814
3815 bool rval = false;
3816 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3817 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3818 PyObject* ro;
3819 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3820 if (ro) {
3821 rval = (ro != Py_None && PyString_Check(ro));
3822 if (rval)
3823 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3824 Py_DECREF(ro);
3825 }
3826 }
3827 wxPyEndBlockThreads(blocked);
3828 return rval;
3829 }
3830
3831 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3832 // For this one we simply need to make a string from buf and len
3833 // and send it to the Python method.
3834 bool rval = false;
3835 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3836 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3837 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3838 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3839 Py_DECREF(data);
3840 }
3841 wxPyEndBlockThreads(blocked);
3842 return rval;
3843 }
3844
3845 // Create a new class for wxPython to use
3846 class wxPyTextDataObject : public wxTextDataObject {
3847 public:
3848 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3849 : wxTextDataObject(text) {}
3850
3851 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3852 DEC_PYCALLBACK_STRING__const(GetText);
3853 DEC_PYCALLBACK__STRING(SetText);
3854 PYPRIVATE;
3855 };
3856
3857 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3858 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3859 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3860
3861
3862 // Create a new class for wxPython to use
3863 class wxPyBitmapDataObject : public wxBitmapDataObject {
3864 public:
3865 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3866 : wxBitmapDataObject(bitmap) {}
3867
3868 wxBitmap GetBitmap() const;
3869 void SetBitmap(const wxBitmap& bitmap);
3870 PYPRIVATE;
3871 };
3872
3873 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3874 wxBitmap* rval = &wxNullBitmap;
3875 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3876 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3877 PyObject* ro;
3878 wxBitmap* ptr;
3879 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3880 if (ro) {
3881 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3882 rval = ptr;
3883 Py_DECREF(ro);
3884 }
3885 }
3886 wxPyEndBlockThreads(blocked);
3887 return *rval;
3888 }
3889
3890 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3892 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3893 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3894 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3895 Py_DECREF(bo);
3896 }
3897 wxPyEndBlockThreads(blocked);
3898 }
3899
3900 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3901 return new wxCustomDataObject(wxDataFormat(formatName));
3902 }
3903 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3904 bool rval;
3905 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3906 if (PyString_Check(data)) {
3907 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3908 }
3909 else {
3910 // raise a TypeError if not a string
3911 PyErr_SetString(PyExc_TypeError, "String expected.");
3912 rval = false;
3913 }
3914 wxPyEndBlockThreads(blocked);
3915 return rval;
3916 }
3917 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3918 PyObject* obj;
3919 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3920 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3921 wxPyEndBlockThreads(blocked);
3922 return obj;
3923 }
3924
3925 class wxMetafileDataObject : public wxDataObjectSimple
3926 {
3927 public:
3928 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3929 };
3930
3931
3932 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3933
3934
3935 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3937 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3938 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3939 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3940
3941
3942 class wxPyTextDropTarget : public wxTextDropTarget {
3943 public:
3944 wxPyTextDropTarget() {}
3945
3946 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3947
3948 DEC_PYCALLBACK__(OnLeave);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3951 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3952 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3953
3954 PYPRIVATE;
3955 };
3956
3957 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3958 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3961 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3962 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3963
3964
3965
3966 class wxPyFileDropTarget : public wxFileDropTarget {
3967 public:
3968 wxPyFileDropTarget() {}
3969
3970 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3971
3972 DEC_PYCALLBACK__(OnLeave);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3975 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3976 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3977
3978 PYPRIVATE;
3979 };
3980
3981 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3982 const wxArrayString& filenames) {
3983 bool rval = false;
3984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3985 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3986 PyObject* list = wxArrayString2PyList_helper(filenames);
3987 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3988 Py_DECREF(list);
3989 }
3990 wxPyEndBlockThreads(blocked);
3991 return rval;
3992 }
3993
3994
3995
3996 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3999 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4000 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4001
4002
4003
4004
4005 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4006
4007 #include <wx/display.h>
4008
4009 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4010 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4011
4012 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
4013 #if !wxUSE_DISPLAY
4014 #include <wx/dynarray.h>
4015 #include <wx/vidmode.h>
4016
4017 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
4018 #include "wx/arrimpl.cpp"
4019 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
4020 const wxVideoMode wxDefaultVideoMode;
4021
4022 class wxDisplay
4023 {
4024 public:
4025 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
4026 ~wxDisplay() {}
4027
4028 static size_t GetCount()
4029 { wxPyRaiseNotImplemented(); return 0; }
4030
4031 static int GetFromPoint(const wxPoint& pt)
4032 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
4033 static int GetFromWindow(wxWindow *window)
4034 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
4035
4036 virtual bool IsOk() const { return false; }
4037 virtual wxRect GetGeometry() const { wxRect r; return r; }
4038 virtual wxString GetName() const { return wxEmptyString; }
4039 bool IsPrimary() const { return false; }
4040
4041 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
4042 { wxArrayVideoModes a; return a; }
4043
4044 virtual wxVideoMode GetCurrentMode() const
4045 { return wxDefaultVideoMode; }
4046
4047 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
4048 { return false; }
4049
4050 void ResetMode() {}
4051 };
4052 #endif
4053
4054 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4055 PyObject* pyList = NULL;
4056 wxArrayVideoModes arr = self->GetModes(mode);
4057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4058 pyList = PyList_New(0);
4059 for (int i=0; i < arr.GetCount(); i++) {
4060 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4061 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4062 PyList_Append(pyList, pyObj);
4063 Py_DECREF(pyObj);
4064 }
4065 wxPyEndBlockThreads(blocked);
4066 return pyList;
4067 }
4068
4069 #include <wx/stdpaths.h>
4070
4071 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4072 return (wxStandardPaths*) &wxStandardPaths::Get();
4073 }
4074 #ifdef __cplusplus
4075 extern "C" {
4076 #endif
4077 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj = 0;
4079 wxSystemColour arg1 ;
4080 wxColour result;
4081 int val1 ;
4082 int ecode1 = 0 ;
4083 PyObject * obj0 = 0 ;
4084 char * kwnames[] = {
4085 (char *) "index", NULL
4086 };
4087
4088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4089 ecode1 = SWIG_AsVal_int(obj0, &val1);
4090 if (!SWIG_IsOK(ecode1)) {
4091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4092 }
4093 arg1 = static_cast< wxSystemColour >(val1);
4094 {
4095 if (!wxPyCheckForApp()) SWIG_fail;
4096 PyThreadState* __tstate = wxPyBeginAllowThreads();
4097 result = wxSystemSettings::GetColour(arg1);
4098 wxPyEndAllowThreads(__tstate);
4099 if (PyErr_Occurred()) SWIG_fail;
4100 }
4101 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4102 return resultobj;
4103 fail:
4104 return NULL;
4105 }
4106
4107
4108 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj = 0;
4110 wxSystemFont arg1 ;
4111 wxFont result;
4112 int val1 ;
4113 int ecode1 = 0 ;
4114 PyObject * obj0 = 0 ;
4115 char * kwnames[] = {
4116 (char *) "index", NULL
4117 };
4118
4119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4120 ecode1 = SWIG_AsVal_int(obj0, &val1);
4121 if (!SWIG_IsOK(ecode1)) {
4122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4123 }
4124 arg1 = static_cast< wxSystemFont >(val1);
4125 {
4126 if (!wxPyCheckForApp()) SWIG_fail;
4127 PyThreadState* __tstate = wxPyBeginAllowThreads();
4128 result = wxSystemSettings::GetFont(arg1);
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4133 return resultobj;
4134 fail:
4135 return NULL;
4136 }
4137
4138
4139 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4140 PyObject *resultobj = 0;
4141 wxSystemMetric arg1 ;
4142 wxWindow *arg2 = (wxWindow *) NULL ;
4143 int result;
4144 int val1 ;
4145 int ecode1 = 0 ;
4146 void *argp2 = 0 ;
4147 int res2 = 0 ;
4148 PyObject * obj0 = 0 ;
4149 PyObject * obj1 = 0 ;
4150 char * kwnames[] = {
4151 (char *) "index",(char *) "win", NULL
4152 };
4153
4154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4155 ecode1 = SWIG_AsVal_int(obj0, &val1);
4156 if (!SWIG_IsOK(ecode1)) {
4157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4158 }
4159 arg1 = static_cast< wxSystemMetric >(val1);
4160 if (obj1) {
4161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4162 if (!SWIG_IsOK(res2)) {
4163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4164 }
4165 arg2 = reinterpret_cast< wxWindow * >(argp2);
4166 }
4167 {
4168 if (!wxPyCheckForApp()) SWIG_fail;
4169 PyThreadState* __tstate = wxPyBeginAllowThreads();
4170 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 resultobj = SWIG_From_int(static_cast< int >(result));
4175 return resultobj;
4176 fail:
4177 return NULL;
4178 }
4179
4180
4181 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4182 PyObject *resultobj = 0;
4183 wxSystemFeature arg1 ;
4184 bool result;
4185 int val1 ;
4186 int ecode1 = 0 ;
4187 PyObject * obj0 = 0 ;
4188 char * kwnames[] = {
4189 (char *) "index", NULL
4190 };
4191
4192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4193 ecode1 = SWIG_AsVal_int(obj0, &val1);
4194 if (!SWIG_IsOK(ecode1)) {
4195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4196 }
4197 arg1 = static_cast< wxSystemFeature >(val1);
4198 {
4199 if (!wxPyCheckForApp()) SWIG_fail;
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 result = (bool)wxSystemSettings::HasFeature(arg1);
4202 wxPyEndAllowThreads(__tstate);
4203 if (PyErr_Occurred()) SWIG_fail;
4204 }
4205 {
4206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4207 }
4208 return resultobj;
4209 fail:
4210 return NULL;
4211 }
4212
4213
4214 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4215 PyObject *resultobj = 0;
4216 wxSystemScreenType result;
4217
4218 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4219 {
4220 if (!wxPyCheckForApp()) SWIG_fail;
4221 PyThreadState* __tstate = wxPyBeginAllowThreads();
4222 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4223 wxPyEndAllowThreads(__tstate);
4224 if (PyErr_Occurred()) SWIG_fail;
4225 }
4226 resultobj = SWIG_From_int(static_cast< int >(result));
4227 return resultobj;
4228 fail:
4229 return NULL;
4230 }
4231
4232
4233 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4234 PyObject *resultobj = 0;
4235 wxSystemScreenType arg1 ;
4236 int val1 ;
4237 int ecode1 = 0 ;
4238 PyObject * obj0 = 0 ;
4239 char * kwnames[] = {
4240 (char *) "screen", NULL
4241 };
4242
4243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4244 ecode1 = SWIG_AsVal_int(obj0, &val1);
4245 if (!SWIG_IsOK(ecode1)) {
4246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4247 }
4248 arg1 = static_cast< wxSystemScreenType >(val1);
4249 {
4250 if (!wxPyCheckForApp()) SWIG_fail;
4251 PyThreadState* __tstate = wxPyBeginAllowThreads();
4252 wxSystemSettings::SetScreenType(arg1);
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 resultobj = SWIG_Py_Void();
4257 return resultobj;
4258 fail:
4259 return NULL;
4260 }
4261
4262
4263 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4264 PyObject *obj;
4265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4266 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4267 return SWIG_Py_Void();
4268 }
4269
4270 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4271 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4272 return 1;
4273 }
4274
4275
4276 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4277 PyObject *pyobj = 0;
4278
4279 {
4280 #if wxUSE_UNICODE
4281 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4282 #else
4283 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4284 #endif
4285 }
4286 return pyobj;
4287 }
4288
4289
4290 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4291 PyObject *resultobj = 0;
4292 wxSystemOptions *result = 0 ;
4293
4294 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4295 {
4296 PyThreadState* __tstate = wxPyBeginAllowThreads();
4297 result = (wxSystemOptions *)new wxSystemOptions();
4298 wxPyEndAllowThreads(__tstate);
4299 if (PyErr_Occurred()) SWIG_fail;
4300 }
4301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4302 return resultobj;
4303 fail:
4304 return NULL;
4305 }
4306
4307
4308 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4309 PyObject *resultobj = 0;
4310 wxString *arg1 = 0 ;
4311 wxString *arg2 = 0 ;
4312 bool temp1 = false ;
4313 bool temp2 = false ;
4314 PyObject * obj0 = 0 ;
4315 PyObject * obj1 = 0 ;
4316 char * kwnames[] = {
4317 (char *) "name",(char *) "value", NULL
4318 };
4319
4320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4321 {
4322 arg1 = wxString_in_helper(obj0);
4323 if (arg1 == NULL) SWIG_fail;
4324 temp1 = true;
4325 }
4326 {
4327 arg2 = wxString_in_helper(obj1);
4328 if (arg2 == NULL) SWIG_fail;
4329 temp2 = true;
4330 }
4331 {
4332 PyThreadState* __tstate = wxPyBeginAllowThreads();
4333 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4334 wxPyEndAllowThreads(__tstate);
4335 if (PyErr_Occurred()) SWIG_fail;
4336 }
4337 resultobj = SWIG_Py_Void();
4338 {
4339 if (temp1)
4340 delete arg1;
4341 }
4342 {
4343 if (temp2)
4344 delete arg2;
4345 }
4346 return resultobj;
4347 fail:
4348 {
4349 if (temp1)
4350 delete arg1;
4351 }
4352 {
4353 if (temp2)
4354 delete arg2;
4355 }
4356 return NULL;
4357 }
4358
4359
4360 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4361 PyObject *resultobj = 0;
4362 wxString *arg1 = 0 ;
4363 int arg2 ;
4364 bool temp1 = false ;
4365 int val2 ;
4366 int ecode2 = 0 ;
4367 PyObject * obj0 = 0 ;
4368 PyObject * obj1 = 0 ;
4369 char * kwnames[] = {
4370 (char *) "name",(char *) "value", NULL
4371 };
4372
4373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4374 {
4375 arg1 = wxString_in_helper(obj0);
4376 if (arg1 == NULL) SWIG_fail;
4377 temp1 = true;
4378 }
4379 ecode2 = SWIG_AsVal_int(obj1, &val2);
4380 if (!SWIG_IsOK(ecode2)) {
4381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4382 }
4383 arg2 = static_cast< int >(val2);
4384 {
4385 PyThreadState* __tstate = wxPyBeginAllowThreads();
4386 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4387 wxPyEndAllowThreads(__tstate);
4388 if (PyErr_Occurred()) SWIG_fail;
4389 }
4390 resultobj = SWIG_Py_Void();
4391 {
4392 if (temp1)
4393 delete arg1;
4394 }
4395 return resultobj;
4396 fail:
4397 {
4398 if (temp1)
4399 delete arg1;
4400 }
4401 return NULL;
4402 }
4403
4404
4405 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4406 PyObject *resultobj = 0;
4407 wxString *arg1 = 0 ;
4408 wxString result;
4409 bool temp1 = false ;
4410 PyObject * obj0 = 0 ;
4411 char * kwnames[] = {
4412 (char *) "name", NULL
4413 };
4414
4415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4416 {
4417 arg1 = wxString_in_helper(obj0);
4418 if (arg1 == NULL) SWIG_fail;
4419 temp1 = true;
4420 }
4421 {
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4424 wxPyEndAllowThreads(__tstate);
4425 if (PyErr_Occurred()) SWIG_fail;
4426 }
4427 {
4428 #if wxUSE_UNICODE
4429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4430 #else
4431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4432 #endif
4433 }
4434 {
4435 if (temp1)
4436 delete arg1;
4437 }
4438 return resultobj;
4439 fail:
4440 {
4441 if (temp1)
4442 delete arg1;
4443 }
4444 return NULL;
4445 }
4446
4447
4448 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4449 PyObject *resultobj = 0;
4450 wxString *arg1 = 0 ;
4451 int result;
4452 bool temp1 = false ;
4453 PyObject * obj0 = 0 ;
4454 char * kwnames[] = {
4455 (char *) "name", NULL
4456 };
4457
4458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4459 {
4460 arg1 = wxString_in_helper(obj0);
4461 if (arg1 == NULL) SWIG_fail;
4462 temp1 = true;
4463 }
4464 {
4465 PyThreadState* __tstate = wxPyBeginAllowThreads();
4466 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4467 wxPyEndAllowThreads(__tstate);
4468 if (PyErr_Occurred()) SWIG_fail;
4469 }
4470 resultobj = SWIG_From_int(static_cast< int >(result));
4471 {
4472 if (temp1)
4473 delete arg1;
4474 }
4475 return resultobj;
4476 fail:
4477 {
4478 if (temp1)
4479 delete arg1;
4480 }
4481 return NULL;
4482 }
4483
4484
4485 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4486 PyObject *resultobj = 0;
4487 wxString *arg1 = 0 ;
4488 bool result;
4489 bool temp1 = false ;
4490 PyObject * obj0 = 0 ;
4491 char * kwnames[] = {
4492 (char *) "name", NULL
4493 };
4494
4495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4496 {
4497 arg1 = wxString_in_helper(obj0);
4498 if (arg1 == NULL) SWIG_fail;
4499 temp1 = true;
4500 }
4501 {
4502 PyThreadState* __tstate = wxPyBeginAllowThreads();
4503 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4504 wxPyEndAllowThreads(__tstate);
4505 if (PyErr_Occurred()) SWIG_fail;
4506 }
4507 {
4508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4509 }
4510 {
4511 if (temp1)
4512 delete arg1;
4513 }
4514 return resultobj;
4515 fail:
4516 {
4517 if (temp1)
4518 delete arg1;
4519 }
4520 return NULL;
4521 }
4522
4523
4524 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4525 PyObject *resultobj = 0;
4526 wxString *arg1 = 0 ;
4527 bool result;
4528 bool temp1 = false ;
4529 PyObject * obj0 = 0 ;
4530 char * kwnames[] = {
4531 (char *) "name", NULL
4532 };
4533
4534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4535 {
4536 arg1 = wxString_in_helper(obj0);
4537 if (arg1 == NULL) SWIG_fail;
4538 temp1 = true;
4539 }
4540 {
4541 PyThreadState* __tstate = wxPyBeginAllowThreads();
4542 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4543 wxPyEndAllowThreads(__tstate);
4544 if (PyErr_Occurred()) SWIG_fail;
4545 }
4546 {
4547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4548 }
4549 {
4550 if (temp1)
4551 delete arg1;
4552 }
4553 return resultobj;
4554 fail:
4555 {
4556 if (temp1)
4557 delete arg1;
4558 }
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4564 PyObject *obj;
4565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4566 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4567 return SWIG_Py_Void();
4568 }
4569
4570 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4571 return SWIG_Python_InitShadowInstance(args);
4572 }
4573
4574 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4575 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4576 return 1;
4577 }
4578
4579
4580 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4581 PyObject *pyobj = 0;
4582
4583 {
4584 #if wxUSE_UNICODE
4585 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4586 #else
4587 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4588 #endif
4589 }
4590 return pyobj;
4591 }
4592
4593
4594 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4595 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4596 return 1;
4597 }
4598
4599
4600 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4601 PyObject *pyobj = 0;
4602
4603 {
4604 #if wxUSE_UNICODE
4605 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4606 #else
4607 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4608 #endif
4609 }
4610 return pyobj;
4611 }
4612
4613
4614 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4615 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4616 return 1;
4617 }
4618
4619
4620 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4621 PyObject *pyobj = 0;
4622
4623 {
4624 #if wxUSE_UNICODE
4625 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4626 #else
4627 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4628 #endif
4629 }
4630 return pyobj;
4631 }
4632
4633
4634 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4635 PyObject *resultobj = 0;
4636 long result;
4637
4638 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4639 {
4640 PyThreadState* __tstate = wxPyBeginAllowThreads();
4641 result = (long)wxNewId();
4642 wxPyEndAllowThreads(__tstate);
4643 if (PyErr_Occurred()) SWIG_fail;
4644 }
4645 resultobj = SWIG_From_long(static_cast< long >(result));
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4653 PyObject *resultobj = 0;
4654 long arg1 ;
4655 long val1 ;
4656 int ecode1 = 0 ;
4657 PyObject * obj0 = 0 ;
4658 char * kwnames[] = {
4659 (char *) "id", NULL
4660 };
4661
4662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4663 ecode1 = SWIG_AsVal_long(obj0, &val1);
4664 if (!SWIG_IsOK(ecode1)) {
4665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4666 }
4667 arg1 = static_cast< long >(val1);
4668 {
4669 PyThreadState* __tstate = wxPyBeginAllowThreads();
4670 wxRegisterId(arg1);
4671 wxPyEndAllowThreads(__tstate);
4672 if (PyErr_Occurred()) SWIG_fail;
4673 }
4674 resultobj = SWIG_Py_Void();
4675 return resultobj;
4676 fail:
4677 return NULL;
4678 }
4679
4680
4681 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4682 PyObject *resultobj = 0;
4683 long result;
4684
4685 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4686 {
4687 PyThreadState* __tstate = wxPyBeginAllowThreads();
4688 result = (long)wxGetCurrentId();
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 resultobj = SWIG_From_long(static_cast< long >(result));
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4700 PyObject *resultobj = 0;
4701 int arg1 ;
4702 bool result;
4703 int val1 ;
4704 int ecode1 = 0 ;
4705 PyObject * obj0 = 0 ;
4706 char * kwnames[] = {
4707 (char *) "id", NULL
4708 };
4709
4710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4711 ecode1 = SWIG_AsVal_int(obj0, &val1);
4712 if (!SWIG_IsOK(ecode1)) {
4713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4714 }
4715 arg1 = static_cast< int >(val1);
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = (bool)wxIsStockID(arg1);
4719 wxPyEndAllowThreads(__tstate);
4720 if (PyErr_Occurred()) SWIG_fail;
4721 }
4722 {
4723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4724 }
4725 return resultobj;
4726 fail:
4727 return NULL;
4728 }
4729
4730
4731 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4732 PyObject *resultobj = 0;
4733 int arg1 ;
4734 wxString *arg2 = 0 ;
4735 bool result;
4736 int val1 ;
4737 int ecode1 = 0 ;
4738 bool temp2 = false ;
4739 PyObject * obj0 = 0 ;
4740 PyObject * obj1 = 0 ;
4741 char * kwnames[] = {
4742 (char *) "id",(char *) "label", NULL
4743 };
4744
4745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4746 ecode1 = SWIG_AsVal_int(obj0, &val1);
4747 if (!SWIG_IsOK(ecode1)) {
4748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4749 }
4750 arg1 = static_cast< int >(val1);
4751 {
4752 arg2 = wxString_in_helper(obj1);
4753 if (arg2 == NULL) SWIG_fail;
4754 temp2 = true;
4755 }
4756 {
4757 PyThreadState* __tstate = wxPyBeginAllowThreads();
4758 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4759 wxPyEndAllowThreads(__tstate);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 {
4763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4764 }
4765 {
4766 if (temp2)
4767 delete arg2;
4768 }
4769 return resultobj;
4770 fail:
4771 {
4772 if (temp2)
4773 delete arg2;
4774 }
4775 return NULL;
4776 }
4777
4778
4779 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4780 PyObject *resultobj = 0;
4781 int arg1 ;
4782 bool arg2 = (bool) true ;
4783 wxString arg3 = (wxString) wxPyEmptyString ;
4784 wxString result;
4785 int val1 ;
4786 int ecode1 = 0 ;
4787 bool val2 ;
4788 int ecode2 = 0 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 PyObject * obj2 = 0 ;
4792 char * kwnames[] = {
4793 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4794 };
4795
4796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4797 ecode1 = SWIG_AsVal_int(obj0, &val1);
4798 if (!SWIG_IsOK(ecode1)) {
4799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4800 }
4801 arg1 = static_cast< int >(val1);
4802 if (obj1) {
4803 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4804 if (!SWIG_IsOK(ecode2)) {
4805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4806 }
4807 arg2 = static_cast< bool >(val2);
4808 }
4809 if (obj2) {
4810 {
4811 wxString* sptr = wxString_in_helper(obj2);
4812 if (sptr == NULL) SWIG_fail;
4813 arg3 = *sptr;
4814 delete sptr;
4815 }
4816 }
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 result = wxGetStockLabel(arg1,arg2,arg3);
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 {
4824 #if wxUSE_UNICODE
4825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4826 #else
4827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4828 #endif
4829 }
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4837 PyObject *resultobj = 0;
4838
4839 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4840 {
4841 if (!wxPyCheckForApp()) SWIG_fail;
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 wxBell();
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_Py_Void();
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4855 PyObject *resultobj = 0;
4856
4857 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4858 {
4859 if (!wxPyCheckForApp()) SWIG_fail;
4860 PyThreadState* __tstate = wxPyBeginAllowThreads();
4861 wxEndBusyCursor();
4862 wxPyEndAllowThreads(__tstate);
4863 if (PyErr_Occurred()) SWIG_fail;
4864 }
4865 resultobj = SWIG_Py_Void();
4866 return resultobj;
4867 fail:
4868 return NULL;
4869 }
4870
4871
4872 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4873 PyObject *resultobj = 0;
4874 bool arg1 = (bool) true ;
4875 long result;
4876 bool val1 ;
4877 int ecode1 = 0 ;
4878 PyObject * obj0 = 0 ;
4879 char * kwnames[] = {
4880 (char *) "resetTimer", NULL
4881 };
4882
4883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4884 if (obj0) {
4885 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4886 if (!SWIG_IsOK(ecode1)) {
4887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4888 }
4889 arg1 = static_cast< bool >(val1);
4890 }
4891 {
4892 PyThreadState* __tstate = wxPyBeginAllowThreads();
4893 result = (long)wxGetElapsedTime(arg1);
4894 wxPyEndAllowThreads(__tstate);
4895 if (PyErr_Occurred()) SWIG_fail;
4896 }
4897 resultobj = SWIG_From_long(static_cast< long >(result));
4898 return resultobj;
4899 fail:
4900 return NULL;
4901 }
4902
4903
4904 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4905 PyObject *resultobj = 0;
4906 bool result;
4907
4908 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4909 {
4910 PyThreadState* __tstate = wxPyBeginAllowThreads();
4911 result = (bool)wxIsBusy();
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 {
4916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4917 }
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4925 PyObject *resultobj = 0;
4926 wxString result;
4927
4928 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4929 {
4930 PyThreadState* __tstate = wxPyBeginAllowThreads();
4931 result = wxNow();
4932 wxPyEndAllowThreads(__tstate);
4933 if (PyErr_Occurred()) SWIG_fail;
4934 }
4935 {
4936 #if wxUSE_UNICODE
4937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4938 #else
4939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4940 #endif
4941 }
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4949 PyObject *resultobj = 0;
4950 wxString const &arg1_defvalue = wxPyEmptyString ;
4951 wxString *arg1 = (wxString *) &arg1_defvalue ;
4952 bool result;
4953 bool temp1 = false ;
4954 PyObject * obj0 = 0 ;
4955 char * kwnames[] = {
4956 (char *) "command", NULL
4957 };
4958
4959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4960 if (obj0) {
4961 {
4962 arg1 = wxString_in_helper(obj0);
4963 if (arg1 == NULL) SWIG_fail;
4964 temp1 = true;
4965 }
4966 }
4967 {
4968 PyThreadState* __tstate = wxPyBeginAllowThreads();
4969 result = (bool)wxShell((wxString const &)*arg1);
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 {
4974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4975 }
4976 {
4977 if (temp1)
4978 delete arg1;
4979 }
4980 return resultobj;
4981 fail:
4982 {
4983 if (temp1)
4984 delete arg1;
4985 }
4986 return NULL;
4987 }
4988
4989
4990 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4991 PyObject *resultobj = 0;
4992
4993 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4994 {
4995 PyThreadState* __tstate = wxPyBeginAllowThreads();
4996 wxStartTimer();
4997 wxPyEndAllowThreads(__tstate);
4998 if (PyErr_Occurred()) SWIG_fail;
4999 }
5000 resultobj = SWIG_Py_Void();
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
5007 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5008 PyObject *resultobj = 0;
5009 int *arg1 = (int *) 0 ;
5010 int *arg2 = (int *) 0 ;
5011 int result;
5012 int temp1 ;
5013 int res1 = SWIG_TMPOBJ ;
5014 int temp2 ;
5015 int res2 = SWIG_TMPOBJ ;
5016
5017 arg1 = &temp1;
5018 arg2 = &temp2;
5019 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5020 {
5021 PyThreadState* __tstate = wxPyBeginAllowThreads();
5022 result = (int)wxGetOsVersion(arg1,arg2);
5023 wxPyEndAllowThreads(__tstate);
5024 if (PyErr_Occurred()) SWIG_fail;
5025 }
5026 resultobj = SWIG_From_int(static_cast< int >(result));
5027 if (SWIG_IsTmpObj(res1)) {
5028 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5029 } else {
5030 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5031 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5032 }
5033 if (SWIG_IsTmpObj(res2)) {
5034 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5035 } else {
5036 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5037 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5038 }
5039 return resultobj;
5040 fail:
5041 return NULL;
5042 }
5043
5044
5045 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5046 PyObject *resultobj = 0;
5047 wxString result;
5048
5049 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5050 {
5051 PyThreadState* __tstate = wxPyBeginAllowThreads();
5052 result = wxGetOsDescription();
5053 wxPyEndAllowThreads(__tstate);
5054 if (PyErr_Occurred()) SWIG_fail;
5055 }
5056 {
5057 #if wxUSE_UNICODE
5058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5059 #else
5060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5061 #endif
5062 }
5063 return resultobj;
5064 fail:
5065 return NULL;
5066 }
5067
5068
5069 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5070 PyObject *resultobj = 0;
5071 wxMemorySize result;
5072
5073 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5074 {
5075 PyThreadState* __tstate = wxPyBeginAllowThreads();
5076 result = wxGetFreeMemory();
5077 wxPyEndAllowThreads(__tstate);
5078 if (PyErr_Occurred()) SWIG_fail;
5079 }
5080 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5081 return resultobj;
5082 fail:
5083 return NULL;
5084 }
5085
5086
5087 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5088 PyObject *resultobj = 0;
5089 wxShutdownFlags arg1 ;
5090 bool result;
5091 int val1 ;
5092 int ecode1 = 0 ;
5093 PyObject * obj0 = 0 ;
5094 char * kwnames[] = {
5095 (char *) "wFlags", NULL
5096 };
5097
5098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5099 ecode1 = SWIG_AsVal_int(obj0, &val1);
5100 if (!SWIG_IsOK(ecode1)) {
5101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5102 }
5103 arg1 = static_cast< wxShutdownFlags >(val1);
5104 {
5105 if (!wxPyCheckForApp()) SWIG_fail;
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 result = (bool)wxShutdown(arg1);
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 {
5112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5113 }
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5121 PyObject *resultobj = 0;
5122 int arg1 ;
5123 int val1 ;
5124 int ecode1 = 0 ;
5125 PyObject * obj0 = 0 ;
5126 char * kwnames[] = {
5127 (char *) "secs", NULL
5128 };
5129
5130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5131 ecode1 = SWIG_AsVal_int(obj0, &val1);
5132 if (!SWIG_IsOK(ecode1)) {
5133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5134 }
5135 arg1 = static_cast< int >(val1);
5136 {
5137 PyThreadState* __tstate = wxPyBeginAllowThreads();
5138 wxSleep(arg1);
5139 wxPyEndAllowThreads(__tstate);
5140 if (PyErr_Occurred()) SWIG_fail;
5141 }
5142 resultobj = SWIG_Py_Void();
5143 return resultobj;
5144 fail:
5145 return NULL;
5146 }
5147
5148
5149 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5150 PyObject *resultobj = 0;
5151 unsigned long arg1 ;
5152 unsigned long val1 ;
5153 int ecode1 = 0 ;
5154 PyObject * obj0 = 0 ;
5155 char * kwnames[] = {
5156 (char *) "milliseconds", NULL
5157 };
5158
5159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5160 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5161 if (!SWIG_IsOK(ecode1)) {
5162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5163 }
5164 arg1 = static_cast< unsigned long >(val1);
5165 {
5166 PyThreadState* __tstate = wxPyBeginAllowThreads();
5167 wxMilliSleep(arg1);
5168 wxPyEndAllowThreads(__tstate);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 resultobj = SWIG_Py_Void();
5172 return resultobj;
5173 fail:
5174 return NULL;
5175 }
5176
5177
5178 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5179 PyObject *resultobj = 0;
5180 unsigned long arg1 ;
5181 unsigned long val1 ;
5182 int ecode1 = 0 ;
5183 PyObject * obj0 = 0 ;
5184 char * kwnames[] = {
5185 (char *) "microseconds", NULL
5186 };
5187
5188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5189 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5190 if (!SWIG_IsOK(ecode1)) {
5191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5192 }
5193 arg1 = static_cast< unsigned long >(val1);
5194 {
5195 PyThreadState* __tstate = wxPyBeginAllowThreads();
5196 wxMicroSleep(arg1);
5197 wxPyEndAllowThreads(__tstate);
5198 if (PyErr_Occurred()) SWIG_fail;
5199 }
5200 resultobj = SWIG_Py_Void();
5201 return resultobj;
5202 fail:
5203 return NULL;
5204 }
5205
5206
5207 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5208 PyObject *resultobj = 0;
5209 bool arg1 ;
5210 bool val1 ;
5211 int ecode1 = 0 ;
5212 PyObject * obj0 = 0 ;
5213 char * kwnames[] = {
5214 (char *) "enable", NULL
5215 };
5216
5217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5218 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5219 if (!SWIG_IsOK(ecode1)) {
5220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5221 }
5222 arg1 = static_cast< bool >(val1);
5223 {
5224 PyThreadState* __tstate = wxPyBeginAllowThreads();
5225 wxEnableTopLevelWindows(arg1);
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 resultobj = SWIG_Py_Void();
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj = 0;
5238 wxString *arg1 = 0 ;
5239 wxString result;
5240 bool temp1 = false ;
5241 PyObject * obj0 = 0 ;
5242 char * kwnames[] = {
5243 (char *) "_in", NULL
5244 };
5245
5246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5247 {
5248 arg1 = wxString_in_helper(obj0);
5249 if (arg1 == NULL) SWIG_fail;
5250 temp1 = true;
5251 }
5252 {
5253 PyThreadState* __tstate = wxPyBeginAllowThreads();
5254 result = wxStripMenuCodes((wxString const &)*arg1);
5255 wxPyEndAllowThreads(__tstate);
5256 if (PyErr_Occurred()) SWIG_fail;
5257 }
5258 {
5259 #if wxUSE_UNICODE
5260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5261 #else
5262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5263 #endif
5264 }
5265 {
5266 if (temp1)
5267 delete arg1;
5268 }
5269 return resultobj;
5270 fail:
5271 {
5272 if (temp1)
5273 delete arg1;
5274 }
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280 PyObject *resultobj = 0;
5281 wxString result;
5282
5283 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5284 {
5285 PyThreadState* __tstate = wxPyBeginAllowThreads();
5286 result = wxGetEmailAddress();
5287 wxPyEndAllowThreads(__tstate);
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 {
5291 #if wxUSE_UNICODE
5292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5293 #else
5294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5295 #endif
5296 }
5297 return resultobj;
5298 fail:
5299 return NULL;
5300 }
5301
5302
5303 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5304 PyObject *resultobj = 0;
5305 wxString result;
5306
5307 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5308 {
5309 PyThreadState* __tstate = wxPyBeginAllowThreads();
5310 result = wxGetHostName();
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 {
5315 #if wxUSE_UNICODE
5316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5317 #else
5318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5319 #endif
5320 }
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5328 PyObject *resultobj = 0;
5329 wxString result;
5330
5331 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5332 {
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 result = wxGetFullHostName();
5335 wxPyEndAllowThreads(__tstate);
5336 if (PyErr_Occurred()) SWIG_fail;
5337 }
5338 {
5339 #if wxUSE_UNICODE
5340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5341 #else
5342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5343 #endif
5344 }
5345 return resultobj;
5346 fail:
5347 return NULL;
5348 }
5349
5350
5351 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5352 PyObject *resultobj = 0;
5353 wxString result;
5354
5355 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5356 {
5357 PyThreadState* __tstate = wxPyBeginAllowThreads();
5358 result = wxGetUserId();
5359 wxPyEndAllowThreads(__tstate);
5360 if (PyErr_Occurred()) SWIG_fail;
5361 }
5362 {
5363 #if wxUSE_UNICODE
5364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5365 #else
5366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5367 #endif
5368 }
5369 return resultobj;
5370 fail:
5371 return NULL;
5372 }
5373
5374
5375 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5376 PyObject *resultobj = 0;
5377 wxString result;
5378
5379 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5380 {
5381 PyThreadState* __tstate = wxPyBeginAllowThreads();
5382 result = wxGetUserName();
5383 wxPyEndAllowThreads(__tstate);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 {
5387 #if wxUSE_UNICODE
5388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5389 #else
5390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5391 #endif
5392 }
5393 return resultobj;
5394 fail:
5395 return NULL;
5396 }
5397
5398
5399 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5400 PyObject *resultobj = 0;
5401 wxString result;
5402
5403 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 result = wxGetHomeDir();
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 {
5411 #if wxUSE_UNICODE
5412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5413 #else
5414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5415 #endif
5416 }
5417 return resultobj;
5418 fail:
5419 return NULL;
5420 }
5421
5422
5423 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5424 PyObject *resultobj = 0;
5425 wxString const &arg1_defvalue = wxPyEmptyString ;
5426 wxString *arg1 = (wxString *) &arg1_defvalue ;
5427 wxString result;
5428 bool temp1 = false ;
5429 PyObject * obj0 = 0 ;
5430 char * kwnames[] = {
5431 (char *) "user", NULL
5432 };
5433
5434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5435 if (obj0) {
5436 {
5437 arg1 = wxString_in_helper(obj0);
5438 if (arg1 == NULL) SWIG_fail;
5439 temp1 = true;
5440 }
5441 }
5442 {
5443 PyThreadState* __tstate = wxPyBeginAllowThreads();
5444 result = wxGetUserHome((wxString const &)*arg1);
5445 wxPyEndAllowThreads(__tstate);
5446 if (PyErr_Occurred()) SWIG_fail;
5447 }
5448 {
5449 #if wxUSE_UNICODE
5450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5451 #else
5452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5453 #endif
5454 }
5455 {
5456 if (temp1)
5457 delete arg1;
5458 }
5459 return resultobj;
5460 fail:
5461 {
5462 if (temp1)
5463 delete arg1;
5464 }
5465 return NULL;
5466 }
5467
5468
5469 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5470 PyObject *resultobj = 0;
5471 unsigned long result;
5472
5473 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 result = (unsigned long)wxGetProcessId();
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5488 PyObject *resultobj = 0;
5489
5490 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5491 {
5492 PyThreadState* __tstate = wxPyBeginAllowThreads();
5493 wxTrap();
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 resultobj = SWIG_Py_Void();
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj = 0;
5506 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5507 wxString *arg1 = (wxString *) &arg1_defvalue ;
5508 wxString const &arg2_defvalue = wxPyEmptyString ;
5509 wxString *arg2 = (wxString *) &arg2_defvalue ;
5510 wxString const &arg3_defvalue = wxPyEmptyString ;
5511 wxString *arg3 = (wxString *) &arg3_defvalue ;
5512 wxString const &arg4_defvalue = wxPyEmptyString ;
5513 wxString *arg4 = (wxString *) &arg4_defvalue ;
5514 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5515 wxString *arg5 = (wxString *) &arg5_defvalue ;
5516 int arg6 = (int) 0 ;
5517 wxWindow *arg7 = (wxWindow *) NULL ;
5518 int arg8 = (int) -1 ;
5519 int arg9 = (int) -1 ;
5520 wxString result;
5521 bool temp1 = false ;
5522 bool temp2 = false ;
5523 bool temp3 = false ;
5524 bool temp4 = false ;
5525 bool temp5 = false ;
5526 int val6 ;
5527 int ecode6 = 0 ;
5528 void *argp7 = 0 ;
5529 int res7 = 0 ;
5530 int val8 ;
5531 int ecode8 = 0 ;
5532 int val9 ;
5533 int ecode9 = 0 ;
5534 PyObject * obj0 = 0 ;
5535 PyObject * obj1 = 0 ;
5536 PyObject * obj2 = 0 ;
5537 PyObject * obj3 = 0 ;
5538 PyObject * obj4 = 0 ;
5539 PyObject * obj5 = 0 ;
5540 PyObject * obj6 = 0 ;
5541 PyObject * obj7 = 0 ;
5542 PyObject * obj8 = 0 ;
5543 char * kwnames[] = {
5544 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5545 };
5546
5547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5548 if (obj0) {
5549 {
5550 arg1 = wxString_in_helper(obj0);
5551 if (arg1 == NULL) SWIG_fail;
5552 temp1 = true;
5553 }
5554 }
5555 if (obj1) {
5556 {
5557 arg2 = wxString_in_helper(obj1);
5558 if (arg2 == NULL) SWIG_fail;
5559 temp2 = true;
5560 }
5561 }
5562 if (obj2) {
5563 {
5564 arg3 = wxString_in_helper(obj2);
5565 if (arg3 == NULL) SWIG_fail;
5566 temp3 = true;
5567 }
5568 }
5569 if (obj3) {
5570 {
5571 arg4 = wxString_in_helper(obj3);
5572 if (arg4 == NULL) SWIG_fail;
5573 temp4 = true;
5574 }
5575 }
5576 if (obj4) {
5577 {
5578 arg5 = wxString_in_helper(obj4);
5579 if (arg5 == NULL) SWIG_fail;
5580 temp5 = true;
5581 }
5582 }
5583 if (obj5) {
5584 ecode6 = SWIG_AsVal_int(obj5, &val6);
5585 if (!SWIG_IsOK(ecode6)) {
5586 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5587 }
5588 arg6 = static_cast< int >(val6);
5589 }
5590 if (obj6) {
5591 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5592 if (!SWIG_IsOK(res7)) {
5593 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5594 }
5595 arg7 = reinterpret_cast< wxWindow * >(argp7);
5596 }
5597 if (obj7) {
5598 ecode8 = SWIG_AsVal_int(obj7, &val8);
5599 if (!SWIG_IsOK(ecode8)) {
5600 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5601 }
5602 arg8 = static_cast< int >(val8);
5603 }
5604 if (obj8) {
5605 ecode9 = SWIG_AsVal_int(obj8, &val9);
5606 if (!SWIG_IsOK(ecode9)) {
5607 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5608 }
5609 arg9 = static_cast< int >(val9);
5610 }
5611 {
5612 if (!wxPyCheckForApp()) SWIG_fail;
5613 PyThreadState* __tstate = wxPyBeginAllowThreads();
5614 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5615 wxPyEndAllowThreads(__tstate);
5616 if (PyErr_Occurred()) SWIG_fail;
5617 }
5618 {
5619 #if wxUSE_UNICODE
5620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5621 #else
5622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5623 #endif
5624 }
5625 {
5626 if (temp1)
5627 delete arg1;
5628 }
5629 {
5630 if (temp2)
5631 delete arg2;
5632 }
5633 {
5634 if (temp3)
5635 delete arg3;
5636 }
5637 {
5638 if (temp4)
5639 delete arg4;
5640 }
5641 {
5642 if (temp5)
5643 delete arg5;
5644 }
5645 return resultobj;
5646 fail:
5647 {
5648 if (temp1)
5649 delete arg1;
5650 }
5651 {
5652 if (temp2)
5653 delete arg2;
5654 }
5655 {
5656 if (temp3)
5657 delete arg3;
5658 }
5659 {
5660 if (temp4)
5661 delete arg4;
5662 }
5663 {
5664 if (temp5)
5665 delete arg5;
5666 }
5667 return NULL;
5668 }
5669
5670
5671 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj = 0;
5673 wxString *arg1 = 0 ;
5674 wxString *arg2 = 0 ;
5675 wxString const &arg3_defvalue = wxPyEmptyString ;
5676 wxString *arg3 = (wxString *) &arg3_defvalue ;
5677 wxWindow *arg4 = (wxWindow *) NULL ;
5678 wxString result;
5679 bool temp1 = false ;
5680 bool temp2 = false ;
5681 bool temp3 = false ;
5682 void *argp4 = 0 ;
5683 int res4 = 0 ;
5684 PyObject * obj0 = 0 ;
5685 PyObject * obj1 = 0 ;
5686 PyObject * obj2 = 0 ;
5687 PyObject * obj3 = 0 ;
5688 char * kwnames[] = {
5689 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5690 };
5691
5692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5693 {
5694 arg1 = wxString_in_helper(obj0);
5695 if (arg1 == NULL) SWIG_fail;
5696 temp1 = true;
5697 }
5698 {
5699 arg2 = wxString_in_helper(obj1);
5700 if (arg2 == NULL) SWIG_fail;
5701 temp2 = true;
5702 }
5703 if (obj2) {
5704 {
5705 arg3 = wxString_in_helper(obj2);
5706 if (arg3 == NULL) SWIG_fail;
5707 temp3 = true;
5708 }
5709 }
5710 if (obj3) {
5711 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5712 if (!SWIG_IsOK(res4)) {
5713 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5714 }
5715 arg4 = reinterpret_cast< wxWindow * >(argp4);
5716 }
5717 {
5718 if (!wxPyCheckForApp()) SWIG_fail;
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5721 wxPyEndAllowThreads(__tstate);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 {
5725 #if wxUSE_UNICODE
5726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5727 #else
5728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5729 #endif
5730 }
5731 {
5732 if (temp1)
5733 delete arg1;
5734 }
5735 {
5736 if (temp2)
5737 delete arg2;
5738 }
5739 {
5740 if (temp3)
5741 delete arg3;
5742 }
5743 return resultobj;
5744 fail:
5745 {
5746 if (temp1)
5747 delete arg1;
5748 }
5749 {
5750 if (temp2)
5751 delete arg2;
5752 }
5753 {
5754 if (temp3)
5755 delete arg3;
5756 }
5757 return NULL;
5758 }
5759
5760
5761 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5762 PyObject *resultobj = 0;
5763 wxString *arg1 = 0 ;
5764 wxString *arg2 = 0 ;
5765 wxString const &arg3_defvalue = wxPyEmptyString ;
5766 wxString *arg3 = (wxString *) &arg3_defvalue ;
5767 wxWindow *arg4 = (wxWindow *) NULL ;
5768 wxString result;
5769 bool temp1 = false ;
5770 bool temp2 = false ;
5771 bool temp3 = false ;
5772 void *argp4 = 0 ;
5773 int res4 = 0 ;
5774 PyObject * obj0 = 0 ;
5775 PyObject * obj1 = 0 ;
5776 PyObject * obj2 = 0 ;
5777 PyObject * obj3 = 0 ;
5778 char * kwnames[] = {
5779 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5780 };
5781
5782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5783 {
5784 arg1 = wxString_in_helper(obj0);
5785 if (arg1 == NULL) SWIG_fail;
5786 temp1 = true;
5787 }
5788 {
5789 arg2 = wxString_in_helper(obj1);
5790 if (arg2 == NULL) SWIG_fail;
5791 temp2 = true;
5792 }
5793 if (obj2) {
5794 {
5795 arg3 = wxString_in_helper(obj2);
5796 if (arg3 == NULL) SWIG_fail;
5797 temp3 = true;
5798 }
5799 }
5800 if (obj3) {
5801 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5802 if (!SWIG_IsOK(res4)) {
5803 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5804 }
5805 arg4 = reinterpret_cast< wxWindow * >(argp4);
5806 }
5807 {
5808 if (!wxPyCheckForApp()) SWIG_fail;
5809 PyThreadState* __tstate = wxPyBeginAllowThreads();
5810 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 {
5815 #if wxUSE_UNICODE
5816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5817 #else
5818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5819 #endif
5820 }
5821 {
5822 if (temp1)
5823 delete arg1;
5824 }
5825 {
5826 if (temp2)
5827 delete arg2;
5828 }
5829 {
5830 if (temp3)
5831 delete arg3;
5832 }
5833 return resultobj;
5834 fail:
5835 {
5836 if (temp1)
5837 delete arg1;
5838 }
5839 {
5840 if (temp2)
5841 delete arg2;
5842 }
5843 {
5844 if (temp3)
5845 delete arg3;
5846 }
5847 return NULL;
5848 }
5849
5850
5851 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5852 PyObject *resultobj = 0;
5853 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5854 wxString *arg1 = (wxString *) &arg1_defvalue ;
5855 wxString const &arg2_defvalue = wxPyEmptyString ;
5856 wxString *arg2 = (wxString *) &arg2_defvalue ;
5857 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5858 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5859 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5860 wxWindow *arg5 = (wxWindow *) NULL ;
5861 wxString result;
5862 bool temp1 = false ;
5863 bool temp2 = false ;
5864 long val3 ;
5865 int ecode3 = 0 ;
5866 wxPoint temp4 ;
5867 void *argp5 = 0 ;
5868 int res5 = 0 ;
5869 PyObject * obj0 = 0 ;
5870 PyObject * obj1 = 0 ;
5871 PyObject * obj2 = 0 ;
5872 PyObject * obj3 = 0 ;
5873 PyObject * obj4 = 0 ;
5874 char * kwnames[] = {
5875 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5876 };
5877
5878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5879 if (obj0) {
5880 {
5881 arg1 = wxString_in_helper(obj0);
5882 if (arg1 == NULL) SWIG_fail;
5883 temp1 = true;
5884 }
5885 }
5886 if (obj1) {
5887 {
5888 arg2 = wxString_in_helper(obj1);
5889 if (arg2 == NULL) SWIG_fail;
5890 temp2 = true;
5891 }
5892 }
5893 if (obj2) {
5894 ecode3 = SWIG_AsVal_long(obj2, &val3);
5895 if (!SWIG_IsOK(ecode3)) {
5896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5897 }
5898 arg3 = static_cast< long >(val3);
5899 }
5900 if (obj3) {
5901 {
5902 arg4 = &temp4;
5903 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5904 }
5905 }
5906 if (obj4) {
5907 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5908 if (!SWIG_IsOK(res5)) {
5909 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5910 }
5911 arg5 = reinterpret_cast< wxWindow * >(argp5);
5912 }
5913 {
5914 if (!wxPyCheckForApp()) SWIG_fail;
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 {
5921 #if wxUSE_UNICODE
5922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5923 #else
5924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5925 #endif
5926 }
5927 {
5928 if (temp1)
5929 delete arg1;
5930 }
5931 {
5932 if (temp2)
5933 delete arg2;
5934 }
5935 return resultobj;
5936 fail:
5937 {
5938 if (temp1)
5939 delete arg1;
5940 }
5941 {
5942 if (temp2)
5943 delete arg2;
5944 }
5945 return NULL;
5946 }
5947
5948
5949 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5950 PyObject *resultobj = 0;
5951 wxString *arg1 = 0 ;
5952 wxString const &arg2_defvalue = wxPyEmptyString ;
5953 wxString *arg2 = (wxString *) &arg2_defvalue ;
5954 wxString const &arg3_defvalue = wxPyEmptyString ;
5955 wxString *arg3 = (wxString *) &arg3_defvalue ;
5956 wxWindow *arg4 = (wxWindow *) NULL ;
5957 int arg5 = (int) -1 ;
5958 int arg6 = (int) -1 ;
5959 bool arg7 = (bool) true ;
5960 wxString result;
5961 bool temp1 = false ;
5962 bool temp2 = false ;
5963 bool temp3 = false ;
5964 void *argp4 = 0 ;
5965 int res4 = 0 ;
5966 int val5 ;
5967 int ecode5 = 0 ;
5968 int val6 ;
5969 int ecode6 = 0 ;
5970 bool val7 ;
5971 int ecode7 = 0 ;
5972 PyObject * obj0 = 0 ;
5973 PyObject * obj1 = 0 ;
5974 PyObject * obj2 = 0 ;
5975 PyObject * obj3 = 0 ;
5976 PyObject * obj4 = 0 ;
5977 PyObject * obj5 = 0 ;
5978 PyObject * obj6 = 0 ;
5979 char * kwnames[] = {
5980 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5981 };
5982
5983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5984 {
5985 arg1 = wxString_in_helper(obj0);
5986 if (arg1 == NULL) SWIG_fail;
5987 temp1 = true;
5988 }
5989 if (obj1) {
5990 {
5991 arg2 = wxString_in_helper(obj1);
5992 if (arg2 == NULL) SWIG_fail;
5993 temp2 = true;
5994 }
5995 }
5996 if (obj2) {
5997 {
5998 arg3 = wxString_in_helper(obj2);
5999 if (arg3 == NULL) SWIG_fail;
6000 temp3 = true;
6001 }
6002 }
6003 if (obj3) {
6004 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6005 if (!SWIG_IsOK(res4)) {
6006 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6007 }
6008 arg4 = reinterpret_cast< wxWindow * >(argp4);
6009 }
6010 if (obj4) {
6011 ecode5 = SWIG_AsVal_int(obj4, &val5);
6012 if (!SWIG_IsOK(ecode5)) {
6013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6014 }
6015 arg5 = static_cast< int >(val5);
6016 }
6017 if (obj5) {
6018 ecode6 = SWIG_AsVal_int(obj5, &val6);
6019 if (!SWIG_IsOK(ecode6)) {
6020 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6021 }
6022 arg6 = static_cast< int >(val6);
6023 }
6024 if (obj6) {
6025 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6026 if (!SWIG_IsOK(ecode7)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6028 }
6029 arg7 = static_cast< bool >(val7);
6030 }
6031 {
6032 if (!wxPyCheckForApp()) SWIG_fail;
6033 PyThreadState* __tstate = wxPyBeginAllowThreads();
6034 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6035 wxPyEndAllowThreads(__tstate);
6036 if (PyErr_Occurred()) SWIG_fail;
6037 }
6038 {
6039 #if wxUSE_UNICODE
6040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6041 #else
6042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6043 #endif
6044 }
6045 {
6046 if (temp1)
6047 delete arg1;
6048 }
6049 {
6050 if (temp2)
6051 delete arg2;
6052 }
6053 {
6054 if (temp3)
6055 delete arg3;
6056 }
6057 return resultobj;
6058 fail:
6059 {
6060 if (temp1)
6061 delete arg1;
6062 }
6063 {
6064 if (temp2)
6065 delete arg2;
6066 }
6067 {
6068 if (temp3)
6069 delete arg3;
6070 }
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj = 0;
6077 wxString *arg1 = 0 ;
6078 wxString const &arg2_defvalue = wxPyEmptyString ;
6079 wxString *arg2 = (wxString *) &arg2_defvalue ;
6080 wxString const &arg3_defvalue = wxPyEmptyString ;
6081 wxString *arg3 = (wxString *) &arg3_defvalue ;
6082 wxWindow *arg4 = (wxWindow *) NULL ;
6083 wxString result;
6084 bool temp1 = false ;
6085 bool temp2 = false ;
6086 bool temp3 = false ;
6087 void *argp4 = 0 ;
6088 int res4 = 0 ;
6089 PyObject * obj0 = 0 ;
6090 PyObject * obj1 = 0 ;
6091 PyObject * obj2 = 0 ;
6092 PyObject * obj3 = 0 ;
6093 char * kwnames[] = {
6094 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6095 };
6096
6097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6098 {
6099 arg1 = wxString_in_helper(obj0);
6100 if (arg1 == NULL) SWIG_fail;
6101 temp1 = true;
6102 }
6103 if (obj1) {
6104 {
6105 arg2 = wxString_in_helper(obj1);
6106 if (arg2 == NULL) SWIG_fail;
6107 temp2 = true;
6108 }
6109 }
6110 if (obj2) {
6111 {
6112 arg3 = wxString_in_helper(obj2);
6113 if (arg3 == NULL) SWIG_fail;
6114 temp3 = true;
6115 }
6116 }
6117 if (obj3) {
6118 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6119 if (!SWIG_IsOK(res4)) {
6120 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6121 }
6122 arg4 = reinterpret_cast< wxWindow * >(argp4);
6123 }
6124 {
6125 if (!wxPyCheckForApp()) SWIG_fail;
6126 PyThreadState* __tstate = wxPyBeginAllowThreads();
6127 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 {
6132 #if wxUSE_UNICODE
6133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6134 #else
6135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6136 #endif
6137 }
6138 {
6139 if (temp1)
6140 delete arg1;
6141 }
6142 {
6143 if (temp2)
6144 delete arg2;
6145 }
6146 {
6147 if (temp3)
6148 delete arg3;
6149 }
6150 return resultobj;
6151 fail:
6152 {
6153 if (temp1)
6154 delete arg1;
6155 }
6156 {
6157 if (temp2)
6158 delete arg2;
6159 }
6160 {
6161 if (temp3)
6162 delete arg3;
6163 }
6164 return NULL;
6165 }
6166
6167
6168 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj = 0;
6170 wxString *arg1 = 0 ;
6171 wxString *arg2 = 0 ;
6172 int arg3 ;
6173 wxString *arg4 = (wxString *) 0 ;
6174 wxWindow *arg5 = (wxWindow *) NULL ;
6175 int arg6 = (int) -1 ;
6176 int arg7 = (int) -1 ;
6177 bool arg8 = (bool) true ;
6178 int arg9 = (int) 150 ;
6179 int arg10 = (int) 200 ;
6180 wxString result;
6181 bool temp1 = false ;
6182 bool temp2 = false ;
6183 void *argp5 = 0 ;
6184 int res5 = 0 ;
6185 int val6 ;
6186 int ecode6 = 0 ;
6187 int val7 ;
6188 int ecode7 = 0 ;
6189 bool val8 ;
6190 int ecode8 = 0 ;
6191 int val9 ;
6192 int ecode9 = 0 ;
6193 int val10 ;
6194 int ecode10 = 0 ;
6195 PyObject * obj0 = 0 ;
6196 PyObject * obj1 = 0 ;
6197 PyObject * obj2 = 0 ;
6198 PyObject * obj3 = 0 ;
6199 PyObject * obj4 = 0 ;
6200 PyObject * obj5 = 0 ;
6201 PyObject * obj6 = 0 ;
6202 PyObject * obj7 = 0 ;
6203 PyObject * obj8 = 0 ;
6204 char * kwnames[] = {
6205 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6206 };
6207
6208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6209 {
6210 arg1 = wxString_in_helper(obj0);
6211 if (arg1 == NULL) SWIG_fail;
6212 temp1 = true;
6213 }
6214 {
6215 arg2 = wxString_in_helper(obj1);
6216 if (arg2 == NULL) SWIG_fail;
6217 temp2 = true;
6218 }
6219 {
6220 arg3 = PyList_Size(obj2);
6221 arg4 = wxString_LIST_helper(obj2);
6222 if (arg4 == NULL) SWIG_fail;
6223 }
6224 if (obj3) {
6225 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6226 if (!SWIG_IsOK(res5)) {
6227 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6228 }
6229 arg5 = reinterpret_cast< wxWindow * >(argp5);
6230 }
6231 if (obj4) {
6232 ecode6 = SWIG_AsVal_int(obj4, &val6);
6233 if (!SWIG_IsOK(ecode6)) {
6234 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6235 }
6236 arg6 = static_cast< int >(val6);
6237 }
6238 if (obj5) {
6239 ecode7 = SWIG_AsVal_int(obj5, &val7);
6240 if (!SWIG_IsOK(ecode7)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6242 }
6243 arg7 = static_cast< int >(val7);
6244 }
6245 if (obj6) {
6246 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6247 if (!SWIG_IsOK(ecode8)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6249 }
6250 arg8 = static_cast< bool >(val8);
6251 }
6252 if (obj7) {
6253 ecode9 = SWIG_AsVal_int(obj7, &val9);
6254 if (!SWIG_IsOK(ecode9)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6256 }
6257 arg9 = static_cast< int >(val9);
6258 }
6259 if (obj8) {
6260 ecode10 = SWIG_AsVal_int(obj8, &val10);
6261 if (!SWIG_IsOK(ecode10)) {
6262 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6263 }
6264 arg10 = static_cast< int >(val10);
6265 }
6266 {
6267 if (!wxPyCheckForApp()) SWIG_fail;
6268 PyThreadState* __tstate = wxPyBeginAllowThreads();
6269 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6270 wxPyEndAllowThreads(__tstate);
6271 if (PyErr_Occurred()) SWIG_fail;
6272 }
6273 {
6274 #if wxUSE_UNICODE
6275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6276 #else
6277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6278 #endif
6279 }
6280 {
6281 if (temp1)
6282 delete arg1;
6283 }
6284 {
6285 if (temp2)
6286 delete arg2;
6287 }
6288 {
6289 if (arg4) delete [] arg4;
6290 }
6291 return resultobj;
6292 fail:
6293 {
6294 if (temp1)
6295 delete arg1;
6296 }
6297 {
6298 if (temp2)
6299 delete arg2;
6300 }
6301 {
6302 if (arg4) delete [] arg4;
6303 }
6304 return NULL;
6305 }
6306
6307
6308 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj = 0;
6310 wxString *arg1 = 0 ;
6311 wxString *arg2 = 0 ;
6312 int arg3 ;
6313 wxString *arg4 = (wxString *) 0 ;
6314 wxWindow *arg5 = (wxWindow *) NULL ;
6315 int arg6 = (int) -1 ;
6316 int arg7 = (int) -1 ;
6317 bool arg8 = (bool) true ;
6318 int arg9 = (int) 150 ;
6319 int arg10 = (int) 200 ;
6320 int result;
6321 bool temp1 = false ;
6322 bool temp2 = false ;
6323 void *argp5 = 0 ;
6324 int res5 = 0 ;
6325 int val6 ;
6326 int ecode6 = 0 ;
6327 int val7 ;
6328 int ecode7 = 0 ;
6329 bool val8 ;
6330 int ecode8 = 0 ;
6331 int val9 ;
6332 int ecode9 = 0 ;
6333 int val10 ;
6334 int ecode10 = 0 ;
6335 PyObject * obj0 = 0 ;
6336 PyObject * obj1 = 0 ;
6337 PyObject * obj2 = 0 ;
6338 PyObject * obj3 = 0 ;
6339 PyObject * obj4 = 0 ;
6340 PyObject * obj5 = 0 ;
6341 PyObject * obj6 = 0 ;
6342 PyObject * obj7 = 0 ;
6343 PyObject * obj8 = 0 ;
6344 char * kwnames[] = {
6345 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6346 };
6347
6348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6349 {
6350 arg1 = wxString_in_helper(obj0);
6351 if (arg1 == NULL) SWIG_fail;
6352 temp1 = true;
6353 }
6354 {
6355 arg2 = wxString_in_helper(obj1);
6356 if (arg2 == NULL) SWIG_fail;
6357 temp2 = true;
6358 }
6359 {
6360 arg3 = PyList_Size(obj2);
6361 arg4 = wxString_LIST_helper(obj2);
6362 if (arg4 == NULL) SWIG_fail;
6363 }
6364 if (obj3) {
6365 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6366 if (!SWIG_IsOK(res5)) {
6367 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6368 }
6369 arg5 = reinterpret_cast< wxWindow * >(argp5);
6370 }
6371 if (obj4) {
6372 ecode6 = SWIG_AsVal_int(obj4, &val6);
6373 if (!SWIG_IsOK(ecode6)) {
6374 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6375 }
6376 arg6 = static_cast< int >(val6);
6377 }
6378 if (obj5) {
6379 ecode7 = SWIG_AsVal_int(obj5, &val7);
6380 if (!SWIG_IsOK(ecode7)) {
6381 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6382 }
6383 arg7 = static_cast< int >(val7);
6384 }
6385 if (obj6) {
6386 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6387 if (!SWIG_IsOK(ecode8)) {
6388 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6389 }
6390 arg8 = static_cast< bool >(val8);
6391 }
6392 if (obj7) {
6393 ecode9 = SWIG_AsVal_int(obj7, &val9);
6394 if (!SWIG_IsOK(ecode9)) {
6395 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6396 }
6397 arg9 = static_cast< int >(val9);
6398 }
6399 if (obj8) {
6400 ecode10 = SWIG_AsVal_int(obj8, &val10);
6401 if (!SWIG_IsOK(ecode10)) {
6402 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6403 }
6404 arg10 = static_cast< int >(val10);
6405 }
6406 {
6407 if (!wxPyCheckForApp()) SWIG_fail;
6408 PyThreadState* __tstate = wxPyBeginAllowThreads();
6409 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6410 wxPyEndAllowThreads(__tstate);
6411 if (PyErr_Occurred()) SWIG_fail;
6412 }
6413 resultobj = SWIG_From_int(static_cast< int >(result));
6414 {
6415 if (temp1)
6416 delete arg1;
6417 }
6418 {
6419 if (temp2)
6420 delete arg2;
6421 }
6422 {
6423 if (arg4) delete [] arg4;
6424 }
6425 return resultobj;
6426 fail:
6427 {
6428 if (temp1)
6429 delete arg1;
6430 }
6431 {
6432 if (temp2)
6433 delete arg2;
6434 }
6435 {
6436 if (arg4) delete [] arg4;
6437 }
6438 return NULL;
6439 }
6440
6441
6442 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6443 PyObject *resultobj = 0;
6444 wxString *arg1 = 0 ;
6445 wxString const &arg2_defvalue = wxPyEmptyString ;
6446 wxString *arg2 = (wxString *) &arg2_defvalue ;
6447 int arg3 = (int) wxOK|wxCENTRE ;
6448 wxWindow *arg4 = (wxWindow *) NULL ;
6449 int arg5 = (int) -1 ;
6450 int arg6 = (int) -1 ;
6451 int result;
6452 bool temp1 = false ;
6453 bool temp2 = false ;
6454 int val3 ;
6455 int ecode3 = 0 ;
6456 void *argp4 = 0 ;
6457 int res4 = 0 ;
6458 int val5 ;
6459 int ecode5 = 0 ;
6460 int val6 ;
6461 int ecode6 = 0 ;
6462 PyObject * obj0 = 0 ;
6463 PyObject * obj1 = 0 ;
6464 PyObject * obj2 = 0 ;
6465 PyObject * obj3 = 0 ;
6466 PyObject * obj4 = 0 ;
6467 PyObject * obj5 = 0 ;
6468 char * kwnames[] = {
6469 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6470 };
6471
6472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6473 {
6474 arg1 = wxString_in_helper(obj0);
6475 if (arg1 == NULL) SWIG_fail;
6476 temp1 = true;
6477 }
6478 if (obj1) {
6479 {
6480 arg2 = wxString_in_helper(obj1);
6481 if (arg2 == NULL) SWIG_fail;
6482 temp2 = true;
6483 }
6484 }
6485 if (obj2) {
6486 ecode3 = SWIG_AsVal_int(obj2, &val3);
6487 if (!SWIG_IsOK(ecode3)) {
6488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6489 }
6490 arg3 = static_cast< int >(val3);
6491 }
6492 if (obj3) {
6493 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6494 if (!SWIG_IsOK(res4)) {
6495 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6496 }
6497 arg4 = reinterpret_cast< wxWindow * >(argp4);
6498 }
6499 if (obj4) {
6500 ecode5 = SWIG_AsVal_int(obj4, &val5);
6501 if (!SWIG_IsOK(ecode5)) {
6502 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6503 }
6504 arg5 = static_cast< int >(val5);
6505 }
6506 if (obj5) {
6507 ecode6 = SWIG_AsVal_int(obj5, &val6);
6508 if (!SWIG_IsOK(ecode6)) {
6509 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6510 }
6511 arg6 = static_cast< int >(val6);
6512 }
6513 {
6514 if (!wxPyCheckForApp()) SWIG_fail;
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 resultobj = SWIG_From_int(static_cast< int >(result));
6521 {
6522 if (temp1)
6523 delete arg1;
6524 }
6525 {
6526 if (temp2)
6527 delete arg2;
6528 }
6529 return resultobj;
6530 fail:
6531 {
6532 if (temp1)
6533 delete arg1;
6534 }
6535 {
6536 if (temp2)
6537 delete arg2;
6538 }
6539 return NULL;
6540 }
6541
6542
6543 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6544 PyObject *resultobj = 0;
6545 bool result;
6546
6547 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6548 {
6549 if (!wxPyCheckForApp()) SWIG_fail;
6550 PyThreadState* __tstate = wxPyBeginAllowThreads();
6551 result = (bool)wxColourDisplay();
6552 wxPyEndAllowThreads(__tstate);
6553 if (PyErr_Occurred()) SWIG_fail;
6554 }
6555 {
6556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6557 }
6558 return resultobj;
6559 fail:
6560 return NULL;
6561 }
6562
6563
6564 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6565 PyObject *resultobj = 0;
6566 int result;
6567
6568 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6569 {
6570 if (!wxPyCheckForApp()) SWIG_fail;
6571 PyThreadState* __tstate = wxPyBeginAllowThreads();
6572 result = (int)wxDisplayDepth();
6573 wxPyEndAllowThreads(__tstate);
6574 if (PyErr_Occurred()) SWIG_fail;
6575 }
6576 resultobj = SWIG_From_int(static_cast< int >(result));
6577 return resultobj;
6578 fail:
6579 return NULL;
6580 }
6581
6582
6583 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6584 PyObject *resultobj = 0;
6585 int result;
6586
6587 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6588 {
6589 if (!wxPyCheckForApp()) SWIG_fail;
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 result = (int)wxGetDisplayDepth();
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 resultobj = SWIG_From_int(static_cast< int >(result));
6596 return resultobj;
6597 fail:
6598 return NULL;
6599 }
6600
6601
6602 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6603 PyObject *resultobj = 0;
6604 int *arg1 = (int *) 0 ;
6605 int *arg2 = (int *) 0 ;
6606 int temp1 ;
6607 int res1 = SWIG_TMPOBJ ;
6608 int temp2 ;
6609 int res2 = SWIG_TMPOBJ ;
6610
6611 arg1 = &temp1;
6612 arg2 = &temp2;
6613 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6614 {
6615 if (!wxPyCheckForApp()) SWIG_fail;
6616 PyThreadState* __tstate = wxPyBeginAllowThreads();
6617 wxDisplaySize(arg1,arg2);
6618 wxPyEndAllowThreads(__tstate);
6619 if (PyErr_Occurred()) SWIG_fail;
6620 }
6621 resultobj = SWIG_Py_Void();
6622 if (SWIG_IsTmpObj(res1)) {
6623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6624 } else {
6625 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6627 }
6628 if (SWIG_IsTmpObj(res2)) {
6629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6630 } else {
6631 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6633 }
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6641 PyObject *resultobj = 0;
6642 wxSize result;
6643
6644 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6645 {
6646 if (!wxPyCheckForApp()) SWIG_fail;
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 result = wxGetDisplaySize();
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6653 return resultobj;
6654 fail:
6655 return NULL;
6656 }
6657
6658
6659 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6660 PyObject *resultobj = 0;
6661 int *arg1 = (int *) 0 ;
6662 int *arg2 = (int *) 0 ;
6663 int temp1 ;
6664 int res1 = SWIG_TMPOBJ ;
6665 int temp2 ;
6666 int res2 = SWIG_TMPOBJ ;
6667
6668 arg1 = &temp1;
6669 arg2 = &temp2;
6670 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6671 {
6672 if (!wxPyCheckForApp()) SWIG_fail;
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 wxDisplaySizeMM(arg1,arg2);
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 resultobj = SWIG_Py_Void();
6679 if (SWIG_IsTmpObj(res1)) {
6680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6681 } else {
6682 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6684 }
6685 if (SWIG_IsTmpObj(res2)) {
6686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6687 } else {
6688 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6690 }
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6698 PyObject *resultobj = 0;
6699 wxSize result;
6700
6701 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6702 {
6703 if (!wxPyCheckForApp()) SWIG_fail;
6704 PyThreadState* __tstate = wxPyBeginAllowThreads();
6705 result = wxGetDisplaySizeMM();
6706 wxPyEndAllowThreads(__tstate);
6707 if (PyErr_Occurred()) SWIG_fail;
6708 }
6709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6710 return resultobj;
6711 fail:
6712 return NULL;
6713 }
6714
6715
6716 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6717 PyObject *resultobj = 0;
6718 int *arg1 = (int *) 0 ;
6719 int *arg2 = (int *) 0 ;
6720 int *arg3 = (int *) 0 ;
6721 int *arg4 = (int *) 0 ;
6722 int temp1 ;
6723 int res1 = SWIG_TMPOBJ ;
6724 int temp2 ;
6725 int res2 = SWIG_TMPOBJ ;
6726 int temp3 ;
6727 int res3 = SWIG_TMPOBJ ;
6728 int temp4 ;
6729 int res4 = SWIG_TMPOBJ ;
6730
6731 arg1 = &temp1;
6732 arg2 = &temp2;
6733 arg3 = &temp3;
6734 arg4 = &temp4;
6735 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6736 {
6737 if (!wxPyCheckForApp()) SWIG_fail;
6738 PyThreadState* __tstate = wxPyBeginAllowThreads();
6739 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 resultobj = SWIG_Py_Void();
6744 if (SWIG_IsTmpObj(res1)) {
6745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6746 } else {
6747 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6749 }
6750 if (SWIG_IsTmpObj(res2)) {
6751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6752 } else {
6753 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6755 }
6756 if (SWIG_IsTmpObj(res3)) {
6757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6758 } else {
6759 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6761 }
6762 if (SWIG_IsTmpObj(res4)) {
6763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6764 } else {
6765 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6767 }
6768 return resultobj;
6769 fail:
6770 return NULL;
6771 }
6772
6773
6774 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6775 PyObject *resultobj = 0;
6776 wxRect result;
6777
6778 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6779 {
6780 if (!wxPyCheckForApp()) SWIG_fail;
6781 PyThreadState* __tstate = wxPyBeginAllowThreads();
6782 result = wxGetClientDisplayRect();
6783 wxPyEndAllowThreads(__tstate);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6794 PyObject *resultobj = 0;
6795 wxCursor *arg1 = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 PyObject * obj0 = 0 ;
6799 char * kwnames[] = {
6800 (char *) "cursor", NULL
6801 };
6802
6803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6804 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6805 if (!SWIG_IsOK(res1)) {
6806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6807 }
6808 if (!argp1) {
6809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6810 }
6811 arg1 = reinterpret_cast< wxCursor * >(argp1);
6812 {
6813 if (!wxPyCheckForApp()) SWIG_fail;
6814 PyThreadState* __tstate = wxPyBeginAllowThreads();
6815 wxSetCursor(*arg1);
6816 wxPyEndAllowThreads(__tstate);
6817 if (PyErr_Occurred()) SWIG_fail;
6818 }
6819 resultobj = SWIG_Py_Void();
6820 return resultobj;
6821 fail:
6822 return NULL;
6823 }
6824
6825
6826 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6827 PyObject *resultobj = 0;
6828 void *result = 0 ;
6829
6830 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6831 {
6832 if (!wxPyCheckForApp()) SWIG_fail;
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (void *)wxGetXDisplay();
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj = 0;
6847 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject * obj0 = 0 ;
6851 char * kwnames[] = {
6852 (char *) "cursor", NULL
6853 };
6854
6855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6856 if (obj0) {
6857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6858 if (!SWIG_IsOK(res1)) {
6859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6860 }
6861 arg1 = reinterpret_cast< wxCursor * >(argp1);
6862 }
6863 {
6864 if (!wxPyCheckForApp()) SWIG_fail;
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 wxBeginBusyCursor(arg1);
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 resultobj = SWIG_Py_Void();
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6878 PyObject *resultobj = 0;
6879 wxPoint result;
6880
6881 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6882 {
6883 if (!wxPyCheckForApp()) SWIG_fail;
6884 PyThreadState* __tstate = wxPyBeginAllowThreads();
6885 result = wxGetMousePosition();
6886 wxPyEndAllowThreads(__tstate);
6887 if (PyErr_Occurred()) SWIG_fail;
6888 }
6889 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6890 return resultobj;
6891 fail:
6892 return NULL;
6893 }
6894
6895
6896 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6897 PyObject *resultobj = 0;
6898 wxWindow *result = 0 ;
6899
6900 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6901 {
6902 if (!wxPyCheckForApp()) SWIG_fail;
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 result = (wxWindow *)FindWindowAtPointer();
6905 wxPyEndAllowThreads(__tstate);
6906 if (PyErr_Occurred()) SWIG_fail;
6907 }
6908 {
6909 resultobj = wxPyMake_wxObject(result, 0);
6910 }
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6918 PyObject *resultobj = 0;
6919 wxWindow *result = 0 ;
6920
6921 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6922 {
6923 if (!wxPyCheckForApp()) SWIG_fail;
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = (wxWindow *)wxGetActiveWindow();
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 {
6930 resultobj = wxPyMake_wxObject(result, 0);
6931 }
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6939 PyObject *resultobj = 0;
6940 wxPoint *arg1 = 0 ;
6941 wxWindow *result = 0 ;
6942 wxPoint temp1 ;
6943 PyObject * obj0 = 0 ;
6944 char * kwnames[] = {
6945 (char *) "pt", NULL
6946 };
6947
6948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6949 {
6950 arg1 = &temp1;
6951 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6952 }
6953 {
6954 if (!wxPyCheckForApp()) SWIG_fail;
6955 PyThreadState* __tstate = wxPyBeginAllowThreads();
6956 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6957 wxPyEndAllowThreads(__tstate);
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 {
6961 resultobj = wxPyMake_wxObject(result, 0);
6962 }
6963 return resultobj;
6964 fail:
6965 return NULL;
6966 }
6967
6968
6969 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6970 PyObject *resultobj = 0;
6971 wxPoint *arg1 = 0 ;
6972 wxWindow *result = 0 ;
6973 wxPoint temp1 ;
6974 PyObject * obj0 = 0 ;
6975 char * kwnames[] = {
6976 (char *) "pt", NULL
6977 };
6978
6979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6980 {
6981 arg1 = &temp1;
6982 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6983 }
6984 {
6985 if (!wxPyCheckForApp()) SWIG_fail;
6986 PyThreadState* __tstate = wxPyBeginAllowThreads();
6987 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6988 wxPyEndAllowThreads(__tstate);
6989 if (PyErr_Occurred()) SWIG_fail;
6990 }
6991 {
6992 resultobj = wxPyMake_wxObject(result, 0);
6993 }
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = 0;
7002 wxWindow *arg1 = (wxWindow *) 0 ;
7003 wxWindow *result = 0 ;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 PyObject * obj0 = 0 ;
7007 char * kwnames[] = {
7008 (char *) "win", NULL
7009 };
7010
7011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7013 if (!SWIG_IsOK(res1)) {
7014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7015 }
7016 arg1 = reinterpret_cast< wxWindow * >(argp1);
7017 {
7018 if (!wxPyCheckForApp()) SWIG_fail;
7019 PyThreadState* __tstate = wxPyBeginAllowThreads();
7020 result = (wxWindow *)wxGetTopLevelParent(arg1);
7021 wxPyEndAllowThreads(__tstate);
7022 if (PyErr_Occurred()) SWIG_fail;
7023 }
7024 {
7025 resultobj = wxPyMake_wxObject(result, 0);
7026 }
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7034 PyObject *resultobj = 0;
7035 wxString *arg1 = 0 ;
7036 bool result;
7037 bool temp1 = false ;
7038 PyObject * obj0 = 0 ;
7039 char * kwnames[] = {
7040 (char *) "url", NULL
7041 };
7042
7043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7044 {
7045 arg1 = wxString_in_helper(obj0);
7046 if (arg1 == NULL) SWIG_fail;
7047 temp1 = true;
7048 }
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 {
7056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7057 }
7058 {
7059 if (temp1)
7060 delete arg1;
7061 }
7062 return resultobj;
7063 fail:
7064 {
7065 if (temp1)
7066 delete arg1;
7067 }
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxKeyCode arg1 ;
7075 bool result;
7076 int val1 ;
7077 int ecode1 = 0 ;
7078 PyObject * obj0 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "key", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7084 ecode1 = SWIG_AsVal_int(obj0, &val1);
7085 if (!SWIG_IsOK(ecode1)) {
7086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7087 }
7088 arg1 = static_cast< wxKeyCode >(val1);
7089 {
7090 if (!wxPyCheckForApp()) SWIG_fail;
7091 PyThreadState* __tstate = wxPyBeginAllowThreads();
7092 result = (bool)wxGetKeyState(arg1);
7093 wxPyEndAllowThreads(__tstate);
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 {
7097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7098 }
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7106 PyObject *resultobj = 0;
7107 wxMouseState *result = 0 ;
7108
7109 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7110 {
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = (wxMouseState *)new wxMouseState();
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7124 PyObject *resultobj = 0;
7125 wxMouseState *arg1 = (wxMouseState *) 0 ;
7126 void *argp1 = 0 ;
7127 int res1 = 0 ;
7128 PyObject *swig_obj[1] ;
7129
7130 if (!args) SWIG_fail;
7131 swig_obj[0] = args;
7132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7133 if (!SWIG_IsOK(res1)) {
7134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7135 }
7136 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7137 {
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 delete arg1;
7140
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 resultobj = SWIG_Py_Void();
7145 return resultobj;
7146 fail:
7147 return NULL;
7148 }
7149
7150
7151 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7152 PyObject *resultobj = 0;
7153 wxMouseState *arg1 = (wxMouseState *) 0 ;
7154 int result;
7155 void *argp1 = 0 ;
7156 int res1 = 0 ;
7157 PyObject *swig_obj[1] ;
7158
7159 if (!args) SWIG_fail;
7160 swig_obj[0] = args;
7161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7162 if (!SWIG_IsOK(res1)) {
7163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7164 }
7165 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7166 {
7167 PyThreadState* __tstate = wxPyBeginAllowThreads();
7168 result = (int)(arg1)->GetX();
7169 wxPyEndAllowThreads(__tstate);
7170 if (PyErr_Occurred()) SWIG_fail;
7171 }
7172 resultobj = SWIG_From_int(static_cast< int >(result));
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7180 PyObject *resultobj = 0;
7181 wxMouseState *arg1 = (wxMouseState *) 0 ;
7182 int result;
7183 void *argp1 = 0 ;
7184 int res1 = 0 ;
7185 PyObject *swig_obj[1] ;
7186
7187 if (!args) SWIG_fail;
7188 swig_obj[0] = args;
7189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7190 if (!SWIG_IsOK(res1)) {
7191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7192 }
7193 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7194 {
7195 PyThreadState* __tstate = wxPyBeginAllowThreads();
7196 result = (int)(arg1)->GetY();
7197 wxPyEndAllowThreads(__tstate);
7198 if (PyErr_Occurred()) SWIG_fail;
7199 }
7200 resultobj = SWIG_From_int(static_cast< int >(result));
7201 return resultobj;
7202 fail:
7203 return NULL;
7204 }
7205
7206
7207 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7208 PyObject *resultobj = 0;
7209 wxMouseState *arg1 = (wxMouseState *) 0 ;
7210 bool result;
7211 void *argp1 = 0 ;
7212 int res1 = 0 ;
7213 PyObject *swig_obj[1] ;
7214
7215 if (!args) SWIG_fail;
7216 swig_obj[0] = args;
7217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7220 }
7221 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7222 {
7223 PyThreadState* __tstate = wxPyBeginAllowThreads();
7224 result = (bool)(arg1)->LeftDown();
7225 wxPyEndAllowThreads(__tstate);
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 {
7229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7230 }
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7238 PyObject *resultobj = 0;
7239 wxMouseState *arg1 = (wxMouseState *) 0 ;
7240 bool result;
7241 void *argp1 = 0 ;
7242 int res1 = 0 ;
7243 PyObject *swig_obj[1] ;
7244
7245 if (!args) SWIG_fail;
7246 swig_obj[0] = args;
7247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7248 if (!SWIG_IsOK(res1)) {
7249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7250 }
7251 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7252 {
7253 PyThreadState* __tstate = wxPyBeginAllowThreads();
7254 result = (bool)(arg1)->MiddleDown();
7255 wxPyEndAllowThreads(__tstate);
7256 if (PyErr_Occurred()) SWIG_fail;
7257 }
7258 {
7259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7260 }
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7268 PyObject *resultobj = 0;
7269 wxMouseState *arg1 = (wxMouseState *) 0 ;
7270 bool result;
7271 void *argp1 = 0 ;
7272 int res1 = 0 ;
7273 PyObject *swig_obj[1] ;
7274
7275 if (!args) SWIG_fail;
7276 swig_obj[0] = args;
7277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7280 }
7281 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7282 {
7283 PyThreadState* __tstate = wxPyBeginAllowThreads();
7284 result = (bool)(arg1)->RightDown();
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 {
7289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7290 }
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
7297 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7298 PyObject *resultobj = 0;
7299 wxMouseState *arg1 = (wxMouseState *) 0 ;
7300 bool result;
7301 void *argp1 = 0 ;
7302 int res1 = 0 ;
7303 PyObject *swig_obj[1] ;
7304
7305 if (!args) SWIG_fail;
7306 swig_obj[0] = args;
7307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7308 if (!SWIG_IsOK(res1)) {
7309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7310 }
7311 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7312 {
7313 PyThreadState* __tstate = wxPyBeginAllowThreads();
7314 result = (bool)(arg1)->ControlDown();
7315 wxPyEndAllowThreads(__tstate);
7316 if (PyErr_Occurred()) SWIG_fail;
7317 }
7318 {
7319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7320 }
7321 return resultobj;
7322 fail:
7323 return NULL;
7324 }
7325
7326
7327 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7328 PyObject *resultobj = 0;
7329 wxMouseState *arg1 = (wxMouseState *) 0 ;
7330 bool result;
7331 void *argp1 = 0 ;
7332 int res1 = 0 ;
7333 PyObject *swig_obj[1] ;
7334
7335 if (!args) SWIG_fail;
7336 swig_obj[0] = args;
7337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7338 if (!SWIG_IsOK(res1)) {
7339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7340 }
7341 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7342 {
7343 PyThreadState* __tstate = wxPyBeginAllowThreads();
7344 result = (bool)(arg1)->ShiftDown();
7345 wxPyEndAllowThreads(__tstate);
7346 if (PyErr_Occurred()) SWIG_fail;
7347 }
7348 {
7349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7350 }
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7358 PyObject *resultobj = 0;
7359 wxMouseState *arg1 = (wxMouseState *) 0 ;
7360 bool result;
7361 void *argp1 = 0 ;
7362 int res1 = 0 ;
7363 PyObject *swig_obj[1] ;
7364
7365 if (!args) SWIG_fail;
7366 swig_obj[0] = args;
7367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7370 }
7371 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 result = (bool)(arg1)->AltDown();
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 {
7379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7380 }
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7388 PyObject *resultobj = 0;
7389 wxMouseState *arg1 = (wxMouseState *) 0 ;
7390 bool result;
7391 void *argp1 = 0 ;
7392 int res1 = 0 ;
7393 PyObject *swig_obj[1] ;
7394
7395 if (!args) SWIG_fail;
7396 swig_obj[0] = args;
7397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7398 if (!SWIG_IsOK(res1)) {
7399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7400 }
7401 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7402 {
7403 PyThreadState* __tstate = wxPyBeginAllowThreads();
7404 result = (bool)(arg1)->MetaDown();
7405 wxPyEndAllowThreads(__tstate);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 {
7409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7410 }
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7418 PyObject *resultobj = 0;
7419 wxMouseState *arg1 = (wxMouseState *) 0 ;
7420 bool result;
7421 void *argp1 = 0 ;
7422 int res1 = 0 ;
7423 PyObject *swig_obj[1] ;
7424
7425 if (!args) SWIG_fail;
7426 swig_obj[0] = args;
7427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7428 if (!SWIG_IsOK(res1)) {
7429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7430 }
7431 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7432 {
7433 PyThreadState* __tstate = wxPyBeginAllowThreads();
7434 result = (bool)(arg1)->CmdDown();
7435 wxPyEndAllowThreads(__tstate);
7436 if (PyErr_Occurred()) SWIG_fail;
7437 }
7438 {
7439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7440 }
7441 return resultobj;
7442 fail:
7443 return NULL;
7444 }
7445
7446
7447 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7448 PyObject *resultobj = 0;
7449 wxMouseState *arg1 = (wxMouseState *) 0 ;
7450 int arg2 ;
7451 void *argp1 = 0 ;
7452 int res1 = 0 ;
7453 int val2 ;
7454 int ecode2 = 0 ;
7455 PyObject * obj0 = 0 ;
7456 PyObject * obj1 = 0 ;
7457 char * kwnames[] = {
7458 (char *) "self",(char *) "x", NULL
7459 };
7460
7461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7463 if (!SWIG_IsOK(res1)) {
7464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7465 }
7466 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7467 ecode2 = SWIG_AsVal_int(obj1, &val2);
7468 if (!SWIG_IsOK(ecode2)) {
7469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7470 }
7471 arg2 = static_cast< int >(val2);
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 (arg1)->SetX(arg2);
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 resultobj = SWIG_Py_Void();
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = 0;
7487 wxMouseState *arg1 = (wxMouseState *) 0 ;
7488 int arg2 ;
7489 void *argp1 = 0 ;
7490 int res1 = 0 ;
7491 int val2 ;
7492 int ecode2 = 0 ;
7493 PyObject * obj0 = 0 ;
7494 PyObject * obj1 = 0 ;
7495 char * kwnames[] = {
7496 (char *) "self",(char *) "y", NULL
7497 };
7498
7499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7503 }
7504 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7505 ecode2 = SWIG_AsVal_int(obj1, &val2);
7506 if (!SWIG_IsOK(ecode2)) {
7507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7508 }
7509 arg2 = static_cast< int >(val2);
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 (arg1)->SetY(arg2);
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 resultobj = SWIG_Py_Void();
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7524 PyObject *resultobj = 0;
7525 wxMouseState *arg1 = (wxMouseState *) 0 ;
7526 bool arg2 ;
7527 void *argp1 = 0 ;
7528 int res1 = 0 ;
7529 bool val2 ;
7530 int ecode2 = 0 ;
7531 PyObject * obj0 = 0 ;
7532 PyObject * obj1 = 0 ;
7533 char * kwnames[] = {
7534 (char *) "self",(char *) "down", NULL
7535 };
7536
7537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7539 if (!SWIG_IsOK(res1)) {
7540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7541 }
7542 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7543 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7544 if (!SWIG_IsOK(ecode2)) {
7545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7546 }
7547 arg2 = static_cast< bool >(val2);
7548 {
7549 PyThreadState* __tstate = wxPyBeginAllowThreads();
7550 (arg1)->SetLeftDown(arg2);
7551 wxPyEndAllowThreads(__tstate);
7552 if (PyErr_Occurred()) SWIG_fail;
7553 }
7554 resultobj = SWIG_Py_Void();
7555 return resultobj;
7556 fail:
7557 return NULL;
7558 }
7559
7560
7561 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7562 PyObject *resultobj = 0;
7563 wxMouseState *arg1 = (wxMouseState *) 0 ;
7564 bool arg2 ;
7565 void *argp1 = 0 ;
7566 int res1 = 0 ;
7567 bool val2 ;
7568 int ecode2 = 0 ;
7569 PyObject * obj0 = 0 ;
7570 PyObject * obj1 = 0 ;
7571 char * kwnames[] = {
7572 (char *) "self",(char *) "down", NULL
7573 };
7574
7575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7577 if (!SWIG_IsOK(res1)) {
7578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7579 }
7580 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7582 if (!SWIG_IsOK(ecode2)) {
7583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7584 }
7585 arg2 = static_cast< bool >(val2);
7586 {
7587 PyThreadState* __tstate = wxPyBeginAllowThreads();
7588 (arg1)->SetMiddleDown(arg2);
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 resultobj = SWIG_Py_Void();
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7600 PyObject *resultobj = 0;
7601 wxMouseState *arg1 = (wxMouseState *) 0 ;
7602 bool arg2 ;
7603 void *argp1 = 0 ;
7604 int res1 = 0 ;
7605 bool val2 ;
7606 int ecode2 = 0 ;
7607 PyObject * obj0 = 0 ;
7608 PyObject * obj1 = 0 ;
7609 char * kwnames[] = {
7610 (char *) "self",(char *) "down", NULL
7611 };
7612
7613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7615 if (!SWIG_IsOK(res1)) {
7616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7617 }
7618 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7619 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7620 if (!SWIG_IsOK(ecode2)) {
7621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7622 }
7623 arg2 = static_cast< bool >(val2);
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 (arg1)->SetRightDown(arg2);
7627 wxPyEndAllowThreads(__tstate);
7628 if (PyErr_Occurred()) SWIG_fail;
7629 }
7630 resultobj = SWIG_Py_Void();
7631 return resultobj;
7632 fail:
7633 return NULL;
7634 }
7635
7636
7637 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7638 PyObject *resultobj = 0;
7639 wxMouseState *arg1 = (wxMouseState *) 0 ;
7640 bool arg2 ;
7641 void *argp1 = 0 ;
7642 int res1 = 0 ;
7643 bool val2 ;
7644 int ecode2 = 0 ;
7645 PyObject * obj0 = 0 ;
7646 PyObject * obj1 = 0 ;
7647 char * kwnames[] = {
7648 (char *) "self",(char *) "down", NULL
7649 };
7650
7651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7653 if (!SWIG_IsOK(res1)) {
7654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7655 }
7656 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7657 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7658 if (!SWIG_IsOK(ecode2)) {
7659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7660 }
7661 arg2 = static_cast< bool >(val2);
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 (arg1)->SetControlDown(arg2);
7665 wxPyEndAllowThreads(__tstate);
7666 if (PyErr_Occurred()) SWIG_fail;
7667 }
7668 resultobj = SWIG_Py_Void();
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7676 PyObject *resultobj = 0;
7677 wxMouseState *arg1 = (wxMouseState *) 0 ;
7678 bool arg2 ;
7679 void *argp1 = 0 ;
7680 int res1 = 0 ;
7681 bool val2 ;
7682 int ecode2 = 0 ;
7683 PyObject * obj0 = 0 ;
7684 PyObject * obj1 = 0 ;
7685 char * kwnames[] = {
7686 (char *) "self",(char *) "down", NULL
7687 };
7688
7689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7691 if (!SWIG_IsOK(res1)) {
7692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7693 }
7694 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7695 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7696 if (!SWIG_IsOK(ecode2)) {
7697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7698 }
7699 arg2 = static_cast< bool >(val2);
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 (arg1)->SetShiftDown(arg2);
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 resultobj = SWIG_Py_Void();
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7714 PyObject *resultobj = 0;
7715 wxMouseState *arg1 = (wxMouseState *) 0 ;
7716 bool arg2 ;
7717 void *argp1 = 0 ;
7718 int res1 = 0 ;
7719 bool val2 ;
7720 int ecode2 = 0 ;
7721 PyObject * obj0 = 0 ;
7722 PyObject * obj1 = 0 ;
7723 char * kwnames[] = {
7724 (char *) "self",(char *) "down", NULL
7725 };
7726
7727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7729 if (!SWIG_IsOK(res1)) {
7730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7731 }
7732 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7733 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7734 if (!SWIG_IsOK(ecode2)) {
7735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7736 }
7737 arg2 = static_cast< bool >(val2);
7738 {
7739 PyThreadState* __tstate = wxPyBeginAllowThreads();
7740 (arg1)->SetAltDown(arg2);
7741 wxPyEndAllowThreads(__tstate);
7742 if (PyErr_Occurred()) SWIG_fail;
7743 }
7744 resultobj = SWIG_Py_Void();
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7752 PyObject *resultobj = 0;
7753 wxMouseState *arg1 = (wxMouseState *) 0 ;
7754 bool arg2 ;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 bool val2 ;
7758 int ecode2 = 0 ;
7759 PyObject * obj0 = 0 ;
7760 PyObject * obj1 = 0 ;
7761 char * kwnames[] = {
7762 (char *) "self",(char *) "down", NULL
7763 };
7764
7765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7767 if (!SWIG_IsOK(res1)) {
7768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7769 }
7770 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7772 if (!SWIG_IsOK(ecode2)) {
7773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7774 }
7775 arg2 = static_cast< bool >(val2);
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 (arg1)->SetMetaDown(arg2);
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 resultobj = SWIG_Py_Void();
7783 return resultobj;
7784 fail:
7785 return NULL;
7786 }
7787
7788
7789 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7790 PyObject *obj;
7791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7792 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7793 return SWIG_Py_Void();
7794 }
7795
7796 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7797 return SWIG_Python_InitShadowInstance(args);
7798 }
7799
7800 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7801 PyObject *resultobj = 0;
7802 wxMouseState result;
7803
7804 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 result = wxGetMouseState();
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7819 PyObject *resultobj = 0;
7820
7821 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7822 {
7823 if (!wxPyCheckForApp()) SWIG_fail;
7824 PyThreadState* __tstate = wxPyBeginAllowThreads();
7825 wxWakeUpMainThread();
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 resultobj = SWIG_Py_Void();
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7837 PyObject *resultobj = 0;
7838
7839 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7840 {
7841 if (!wxPyCheckForApp()) SWIG_fail;
7842 PyThreadState* __tstate = wxPyBeginAllowThreads();
7843 wxMutexGuiEnter();
7844 wxPyEndAllowThreads(__tstate);
7845 if (PyErr_Occurred()) SWIG_fail;
7846 }
7847 resultobj = SWIG_Py_Void();
7848 return resultobj;
7849 fail:
7850 return NULL;
7851 }
7852
7853
7854 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7855 PyObject *resultobj = 0;
7856
7857 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7858 {
7859 if (!wxPyCheckForApp()) SWIG_fail;
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 wxMutexGuiLeave();
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = SWIG_Py_Void();
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7873 PyObject *resultobj = 0;
7874 wxMutexGuiLocker *result = 0 ;
7875
7876 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7877 {
7878 if (!wxPyCheckForApp()) SWIG_fail;
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7881 wxPyEndAllowThreads(__tstate);
7882 if (PyErr_Occurred()) SWIG_fail;
7883 }
7884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7885 return resultobj;
7886 fail:
7887 return NULL;
7888 }
7889
7890
7891 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7892 PyObject *resultobj = 0;
7893 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 PyObject *swig_obj[1] ;
7897
7898 if (!args) SWIG_fail;
7899 swig_obj[0] = args;
7900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7901 if (!SWIG_IsOK(res1)) {
7902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7903 }
7904 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7905 {
7906 PyThreadState* __tstate = wxPyBeginAllowThreads();
7907 delete arg1;
7908
7909 wxPyEndAllowThreads(__tstate);
7910 if (PyErr_Occurred()) SWIG_fail;
7911 }
7912 resultobj = SWIG_Py_Void();
7913 return resultobj;
7914 fail:
7915 return NULL;
7916 }
7917
7918
7919 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7920 PyObject *obj;
7921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7922 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7923 return SWIG_Py_Void();
7924 }
7925
7926 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7927 return SWIG_Python_InitShadowInstance(args);
7928 }
7929
7930 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7931 PyObject *resultobj = 0;
7932 bool result;
7933
7934 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (bool)wxThread_IsMain();
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 {
7942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7943 }
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7951 PyObject *resultobj = 0;
7952 wxString *arg1 = 0 ;
7953 wxToolTip *result = 0 ;
7954 bool temp1 = false ;
7955 PyObject * obj0 = 0 ;
7956 char * kwnames[] = {
7957 (char *) "tip", NULL
7958 };
7959
7960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7961 {
7962 arg1 = wxString_in_helper(obj0);
7963 if (arg1 == NULL) SWIG_fail;
7964 temp1 = true;
7965 }
7966 {
7967 if (!wxPyCheckForApp()) SWIG_fail;
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7970 wxPyEndAllowThreads(__tstate);
7971 if (PyErr_Occurred()) SWIG_fail;
7972 }
7973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7974 {
7975 if (temp1)
7976 delete arg1;
7977 }
7978 return resultobj;
7979 fail:
7980 {
7981 if (temp1)
7982 delete arg1;
7983 }
7984 return NULL;
7985 }
7986
7987
7988 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7989 PyObject *resultobj = 0;
7990 wxToolTip *arg1 = (wxToolTip *) 0 ;
7991 void *argp1 = 0 ;
7992 int res1 = 0 ;
7993 PyObject *swig_obj[1] ;
7994
7995 if (!args) SWIG_fail;
7996 swig_obj[0] = args;
7997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8000 }
8001 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8002 {
8003 PyThreadState* __tstate = wxPyBeginAllowThreads();
8004 delete arg1;
8005
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8017 PyObject *resultobj = 0;
8018 wxToolTip *arg1 = (wxToolTip *) 0 ;
8019 wxString *arg2 = 0 ;
8020 void *argp1 = 0 ;
8021 int res1 = 0 ;
8022 bool temp2 = false ;
8023 PyObject * obj0 = 0 ;
8024 PyObject * obj1 = 0 ;
8025 char * kwnames[] = {
8026 (char *) "self",(char *) "tip", NULL
8027 };
8028
8029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8031 if (!SWIG_IsOK(res1)) {
8032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8033 }
8034 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8035 {
8036 arg2 = wxString_in_helper(obj1);
8037 if (arg2 == NULL) SWIG_fail;
8038 temp2 = true;
8039 }
8040 {
8041 PyThreadState* __tstate = wxPyBeginAllowThreads();
8042 (arg1)->SetTip((wxString const &)*arg2);
8043 wxPyEndAllowThreads(__tstate);
8044 if (PyErr_Occurred()) SWIG_fail;
8045 }
8046 resultobj = SWIG_Py_Void();
8047 {
8048 if (temp2)
8049 delete arg2;
8050 }
8051 return resultobj;
8052 fail:
8053 {
8054 if (temp2)
8055 delete arg2;
8056 }
8057 return NULL;
8058 }
8059
8060
8061 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8062 PyObject *resultobj = 0;
8063 wxToolTip *arg1 = (wxToolTip *) 0 ;
8064 wxString result;
8065 void *argp1 = 0 ;
8066 int res1 = 0 ;
8067 PyObject *swig_obj[1] ;
8068
8069 if (!args) SWIG_fail;
8070 swig_obj[0] = args;
8071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8072 if (!SWIG_IsOK(res1)) {
8073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8074 }
8075 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8076 {
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 result = (arg1)->GetTip();
8079 wxPyEndAllowThreads(__tstate);
8080 if (PyErr_Occurred()) SWIG_fail;
8081 }
8082 {
8083 #if wxUSE_UNICODE
8084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8085 #else
8086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8087 #endif
8088 }
8089 return resultobj;
8090 fail:
8091 return NULL;
8092 }
8093
8094
8095 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8096 PyObject *resultobj = 0;
8097 wxToolTip *arg1 = (wxToolTip *) 0 ;
8098 wxWindow *result = 0 ;
8099 void *argp1 = 0 ;
8100 int res1 = 0 ;
8101 PyObject *swig_obj[1] ;
8102
8103 if (!args) SWIG_fail;
8104 swig_obj[0] = args;
8105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8106 if (!SWIG_IsOK(res1)) {
8107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8108 }
8109 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8110 {
8111 PyThreadState* __tstate = wxPyBeginAllowThreads();
8112 result = (wxWindow *)(arg1)->GetWindow();
8113 wxPyEndAllowThreads(__tstate);
8114 if (PyErr_Occurred()) SWIG_fail;
8115 }
8116 {
8117 resultobj = wxPyMake_wxObject(result, 0);
8118 }
8119 return resultobj;
8120 fail:
8121 return NULL;
8122 }
8123
8124
8125 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8126 PyObject *resultobj = 0;
8127 bool arg1 ;
8128 bool val1 ;
8129 int ecode1 = 0 ;
8130 PyObject * obj0 = 0 ;
8131 char * kwnames[] = {
8132 (char *) "flag", NULL
8133 };
8134
8135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8136 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8137 if (!SWIG_IsOK(ecode1)) {
8138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8139 }
8140 arg1 = static_cast< bool >(val1);
8141 {
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 wxToolTip::Enable(arg1);
8144 wxPyEndAllowThreads(__tstate);
8145 if (PyErr_Occurred()) SWIG_fail;
8146 }
8147 resultobj = SWIG_Py_Void();
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj = 0;
8156 long arg1 ;
8157 long val1 ;
8158 int ecode1 = 0 ;
8159 PyObject * obj0 = 0 ;
8160 char * kwnames[] = {
8161 (char *) "milliseconds", NULL
8162 };
8163
8164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8165 ecode1 = SWIG_AsVal_long(obj0, &val1);
8166 if (!SWIG_IsOK(ecode1)) {
8167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8168 }
8169 arg1 = static_cast< long >(val1);
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 wxToolTip::SetDelay(arg1);
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 resultobj = SWIG_Py_Void();
8177 return resultobj;
8178 fail:
8179 return NULL;
8180 }
8181
8182
8183 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8184 PyObject *obj;
8185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8186 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8187 return SWIG_Py_Void();
8188 }
8189
8190 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8191 return SWIG_Python_InitShadowInstance(args);
8192 }
8193
8194 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj = 0;
8196 wxWindow *arg1 = (wxWindow *) 0 ;
8197 wxSize *arg2 = 0 ;
8198 wxCaret *result = 0 ;
8199 void *argp1 = 0 ;
8200 int res1 = 0 ;
8201 wxSize temp2 ;
8202 PyObject * obj0 = 0 ;
8203 PyObject * obj1 = 0 ;
8204 char * kwnames[] = {
8205 (char *) "window",(char *) "size", NULL
8206 };
8207
8208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8210 if (!SWIG_IsOK(res1)) {
8211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8212 }
8213 arg1 = reinterpret_cast< wxWindow * >(argp1);
8214 {
8215 arg2 = &temp2;
8216 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8217 }
8218 {
8219 if (!wxPyCheckForApp()) SWIG_fail;
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8222 wxPyEndAllowThreads(__tstate);
8223 if (PyErr_Occurred()) SWIG_fail;
8224 }
8225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8226 return resultobj;
8227 fail:
8228 return NULL;
8229 }
8230
8231
8232 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8233 PyObject *resultobj = 0;
8234 wxCaret *arg1 = (wxCaret *) 0 ;
8235 void *argp1 = 0 ;
8236 int res1 = 0 ;
8237 PyObject *swig_obj[1] ;
8238
8239 if (!args) SWIG_fail;
8240 swig_obj[0] = args;
8241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8242 if (!SWIG_IsOK(res1)) {
8243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8244 }
8245 arg1 = reinterpret_cast< wxCaret * >(argp1);
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 delete arg1;
8249
8250 wxPyEndAllowThreads(__tstate);
8251 if (PyErr_Occurred()) SWIG_fail;
8252 }
8253 resultobj = SWIG_Py_Void();
8254 return resultobj;
8255 fail:
8256 return NULL;
8257 }
8258
8259
8260 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8261 PyObject *resultobj = 0;
8262 wxCaret *arg1 = (wxCaret *) 0 ;
8263 void *argp1 = 0 ;
8264 int res1 = 0 ;
8265 PyObject *swig_obj[1] ;
8266
8267 if (!args) SWIG_fail;
8268 swig_obj[0] = args;
8269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8270 if (!SWIG_IsOK(res1)) {
8271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8272 }
8273 arg1 = reinterpret_cast< wxCaret * >(argp1);
8274 {
8275 PyThreadState* __tstate = wxPyBeginAllowThreads();
8276 wxCaret_Destroy(arg1);
8277 wxPyEndAllowThreads(__tstate);
8278 if (PyErr_Occurred()) SWIG_fail;
8279 }
8280 resultobj = SWIG_Py_Void();
8281 return resultobj;
8282 fail:
8283 return NULL;
8284 }
8285
8286
8287 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8288 PyObject *resultobj = 0;
8289 wxCaret *arg1 = (wxCaret *) 0 ;
8290 bool result;
8291 void *argp1 = 0 ;
8292 int res1 = 0 ;
8293 PyObject *swig_obj[1] ;
8294
8295 if (!args) SWIG_fail;
8296 swig_obj[0] = args;
8297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8298 if (!SWIG_IsOK(res1)) {
8299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8300 }
8301 arg1 = reinterpret_cast< wxCaret * >(argp1);
8302 {
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 result = (bool)(arg1)->IsOk();
8305 wxPyEndAllowThreads(__tstate);
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 {
8309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8310 }
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8318 PyObject *resultobj = 0;
8319 wxCaret *arg1 = (wxCaret *) 0 ;
8320 bool result;
8321 void *argp1 = 0 ;
8322 int res1 = 0 ;
8323 PyObject *swig_obj[1] ;
8324
8325 if (!args) SWIG_fail;
8326 swig_obj[0] = args;
8327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8328 if (!SWIG_IsOK(res1)) {
8329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8330 }
8331 arg1 = reinterpret_cast< wxCaret * >(argp1);
8332 {
8333 PyThreadState* __tstate = wxPyBeginAllowThreads();
8334 result = (bool)(arg1)->IsVisible();
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 {
8339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8340 }
8341 return resultobj;
8342 fail:
8343 return NULL;
8344 }
8345
8346
8347 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8348 PyObject *resultobj = 0;
8349 wxCaret *arg1 = (wxCaret *) 0 ;
8350 wxPoint result;
8351 void *argp1 = 0 ;
8352 int res1 = 0 ;
8353 PyObject *swig_obj[1] ;
8354
8355 if (!args) SWIG_fail;
8356 swig_obj[0] = args;
8357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8358 if (!SWIG_IsOK(res1)) {
8359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8360 }
8361 arg1 = reinterpret_cast< wxCaret * >(argp1);
8362 {
8363 PyThreadState* __tstate = wxPyBeginAllowThreads();
8364 result = (arg1)->GetPosition();
8365 wxPyEndAllowThreads(__tstate);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8369 return resultobj;
8370 fail:
8371 return NULL;
8372 }
8373
8374
8375 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8376 PyObject *resultobj = 0;
8377 wxCaret *arg1 = (wxCaret *) 0 ;
8378 int *arg2 = (int *) 0 ;
8379 int *arg3 = (int *) 0 ;
8380 void *argp1 = 0 ;
8381 int res1 = 0 ;
8382 int temp2 ;
8383 int res2 = SWIG_TMPOBJ ;
8384 int temp3 ;
8385 int res3 = SWIG_TMPOBJ ;
8386 PyObject *swig_obj[1] ;
8387
8388 arg2 = &temp2;
8389 arg3 = &temp3;
8390 if (!args) SWIG_fail;
8391 swig_obj[0] = args;
8392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8393 if (!SWIG_IsOK(res1)) {
8394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8395 }
8396 arg1 = reinterpret_cast< wxCaret * >(argp1);
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 (arg1)->GetPosition(arg2,arg3);
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_Py_Void();
8404 if (SWIG_IsTmpObj(res2)) {
8405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8406 } else {
8407 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8409 }
8410 if (SWIG_IsTmpObj(res3)) {
8411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8412 } else {
8413 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8415 }
8416 return resultobj;
8417 fail:
8418 return NULL;
8419 }
8420
8421
8422 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8423 PyObject *resultobj = 0;
8424 wxCaret *arg1 = (wxCaret *) 0 ;
8425 wxSize result;
8426 void *argp1 = 0 ;
8427 int res1 = 0 ;
8428 PyObject *swig_obj[1] ;
8429
8430 if (!args) SWIG_fail;
8431 swig_obj[0] = args;
8432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8433 if (!SWIG_IsOK(res1)) {
8434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8435 }
8436 arg1 = reinterpret_cast< wxCaret * >(argp1);
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (arg1)->GetSize();
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8444 return resultobj;
8445 fail:
8446 return NULL;
8447 }
8448
8449
8450 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8451 PyObject *resultobj = 0;
8452 wxCaret *arg1 = (wxCaret *) 0 ;
8453 int *arg2 = (int *) 0 ;
8454 int *arg3 = (int *) 0 ;
8455 void *argp1 = 0 ;
8456 int res1 = 0 ;
8457 int temp2 ;
8458 int res2 = SWIG_TMPOBJ ;
8459 int temp3 ;
8460 int res3 = SWIG_TMPOBJ ;
8461 PyObject *swig_obj[1] ;
8462
8463 arg2 = &temp2;
8464 arg3 = &temp3;
8465 if (!args) SWIG_fail;
8466 swig_obj[0] = args;
8467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8468 if (!SWIG_IsOK(res1)) {
8469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8470 }
8471 arg1 = reinterpret_cast< wxCaret * >(argp1);
8472 {
8473 PyThreadState* __tstate = wxPyBeginAllowThreads();
8474 (arg1)->GetSize(arg2,arg3);
8475 wxPyEndAllowThreads(__tstate);
8476 if (PyErr_Occurred()) SWIG_fail;
8477 }
8478 resultobj = SWIG_Py_Void();
8479 if (SWIG_IsTmpObj(res2)) {
8480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8481 } else {
8482 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8483 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8484 }
8485 if (SWIG_IsTmpObj(res3)) {
8486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8487 } else {
8488 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8490 }
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8498 PyObject *resultobj = 0;
8499 wxCaret *arg1 = (wxCaret *) 0 ;
8500 wxWindow *result = 0 ;
8501 void *argp1 = 0 ;
8502 int res1 = 0 ;
8503 PyObject *swig_obj[1] ;
8504
8505 if (!args) SWIG_fail;
8506 swig_obj[0] = args;
8507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8508 if (!SWIG_IsOK(res1)) {
8509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8510 }
8511 arg1 = reinterpret_cast< wxCaret * >(argp1);
8512 {
8513 PyThreadState* __tstate = wxPyBeginAllowThreads();
8514 result = (wxWindow *)(arg1)->GetWindow();
8515 wxPyEndAllowThreads(__tstate);
8516 if (PyErr_Occurred()) SWIG_fail;
8517 }
8518 {
8519 resultobj = wxPyMake_wxObject(result, 0);
8520 }
8521 return resultobj;
8522 fail:
8523 return NULL;
8524 }
8525
8526
8527 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8528 PyObject *resultobj = 0;
8529 wxCaret *arg1 = (wxCaret *) 0 ;
8530 int arg2 ;
8531 int arg3 ;
8532 void *argp1 = 0 ;
8533 int res1 = 0 ;
8534 int val2 ;
8535 int ecode2 = 0 ;
8536 int val3 ;
8537 int ecode3 = 0 ;
8538 PyObject * obj0 = 0 ;
8539 PyObject * obj1 = 0 ;
8540 PyObject * obj2 = 0 ;
8541 char * kwnames[] = {
8542 (char *) "self",(char *) "x",(char *) "y", NULL
8543 };
8544
8545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8547 if (!SWIG_IsOK(res1)) {
8548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8549 }
8550 arg1 = reinterpret_cast< wxCaret * >(argp1);
8551 ecode2 = SWIG_AsVal_int(obj1, &val2);
8552 if (!SWIG_IsOK(ecode2)) {
8553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8554 }
8555 arg2 = static_cast< int >(val2);
8556 ecode3 = SWIG_AsVal_int(obj2, &val3);
8557 if (!SWIG_IsOK(ecode3)) {
8558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8559 }
8560 arg3 = static_cast< int >(val3);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 (arg1)->Move(arg2,arg3);
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_Py_Void();
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxCaret *arg1 = (wxCaret *) 0 ;
8577 wxPoint *arg2 = 0 ;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 wxPoint temp2 ;
8581 PyObject * obj0 = 0 ;
8582 PyObject * obj1 = 0 ;
8583 char * kwnames[] = {
8584 (char *) "self",(char *) "pt", NULL
8585 };
8586
8587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8589 if (!SWIG_IsOK(res1)) {
8590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8591 }
8592 arg1 = reinterpret_cast< wxCaret * >(argp1);
8593 {
8594 arg2 = &temp2;
8595 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8596 }
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 (arg1)->Move((wxPoint const &)*arg2);
8600 wxPyEndAllowThreads(__tstate);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 resultobj = SWIG_Py_Void();
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8611 PyObject *resultobj = 0;
8612 wxCaret *arg1 = (wxCaret *) 0 ;
8613 int arg2 ;
8614 int arg3 ;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 int val2 ;
8618 int ecode2 = 0 ;
8619 int val3 ;
8620 int ecode3 = 0 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 PyObject * obj2 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "width",(char *) "height", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8632 }
8633 arg1 = reinterpret_cast< wxCaret * >(argp1);
8634 ecode2 = SWIG_AsVal_int(obj1, &val2);
8635 if (!SWIG_IsOK(ecode2)) {
8636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8637 }
8638 arg2 = static_cast< int >(val2);
8639 ecode3 = SWIG_AsVal_int(obj2, &val3);
8640 if (!SWIG_IsOK(ecode3)) {
8641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8642 }
8643 arg3 = static_cast< int >(val3);
8644 {
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 (arg1)->SetSize(arg2,arg3);
8647 wxPyEndAllowThreads(__tstate);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 resultobj = SWIG_Py_Void();
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj = 0;
8659 wxCaret *arg1 = (wxCaret *) 0 ;
8660 wxSize *arg2 = 0 ;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 wxSize temp2 ;
8664 PyObject * obj0 = 0 ;
8665 PyObject * obj1 = 0 ;
8666 char * kwnames[] = {
8667 (char *) "self",(char *) "size", NULL
8668 };
8669
8670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8672 if (!SWIG_IsOK(res1)) {
8673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8674 }
8675 arg1 = reinterpret_cast< wxCaret * >(argp1);
8676 {
8677 arg2 = &temp2;
8678 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8679 }
8680 {
8681 PyThreadState* __tstate = wxPyBeginAllowThreads();
8682 (arg1)->SetSize((wxSize const &)*arg2);
8683 wxPyEndAllowThreads(__tstate);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 resultobj = SWIG_Py_Void();
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj = 0;
8695 wxCaret *arg1 = (wxCaret *) 0 ;
8696 int arg2 = (int) true ;
8697 void *argp1 = 0 ;
8698 int res1 = 0 ;
8699 int val2 ;
8700 int ecode2 = 0 ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char * kwnames[] = {
8704 (char *) "self",(char *) "show", NULL
8705 };
8706
8707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8709 if (!SWIG_IsOK(res1)) {
8710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8711 }
8712 arg1 = reinterpret_cast< wxCaret * >(argp1);
8713 if (obj1) {
8714 ecode2 = SWIG_AsVal_int(obj1, &val2);
8715 if (!SWIG_IsOK(ecode2)) {
8716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8717 }
8718 arg2 = static_cast< int >(val2);
8719 }
8720 {
8721 PyThreadState* __tstate = wxPyBeginAllowThreads();
8722 (arg1)->Show(arg2);
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 resultobj = SWIG_Py_Void();
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8734 PyObject *resultobj = 0;
8735 wxCaret *arg1 = (wxCaret *) 0 ;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 PyObject *swig_obj[1] ;
8739
8740 if (!args) SWIG_fail;
8741 swig_obj[0] = args;
8742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8743 if (!SWIG_IsOK(res1)) {
8744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8745 }
8746 arg1 = reinterpret_cast< wxCaret * >(argp1);
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 (arg1)->Hide();
8750 wxPyEndAllowThreads(__tstate);
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 resultobj = SWIG_Py_Void();
8754 return resultobj;
8755 fail:
8756 return NULL;
8757 }
8758
8759
8760 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8761 PyObject *resultobj = 0;
8762 int result;
8763
8764 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8765 {
8766 PyThreadState* __tstate = wxPyBeginAllowThreads();
8767 result = (int)wxCaret::GetBlinkTime();
8768 wxPyEndAllowThreads(__tstate);
8769 if (PyErr_Occurred()) SWIG_fail;
8770 }
8771 resultobj = SWIG_From_int(static_cast< int >(result));
8772 return resultobj;
8773 fail:
8774 return NULL;
8775 }
8776
8777
8778 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8779 PyObject *resultobj = 0;
8780 int arg1 ;
8781 int val1 ;
8782 int ecode1 = 0 ;
8783 PyObject * obj0 = 0 ;
8784 char * kwnames[] = {
8785 (char *) "milliseconds", NULL
8786 };
8787
8788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8789 ecode1 = SWIG_AsVal_int(obj0, &val1);
8790 if (!SWIG_IsOK(ecode1)) {
8791 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8792 }
8793 arg1 = static_cast< int >(val1);
8794 {
8795 PyThreadState* __tstate = wxPyBeginAllowThreads();
8796 wxCaret::SetBlinkTime(arg1);
8797 wxPyEndAllowThreads(__tstate);
8798 if (PyErr_Occurred()) SWIG_fail;
8799 }
8800 resultobj = SWIG_Py_Void();
8801 return resultobj;
8802 fail:
8803 return NULL;
8804 }
8805
8806
8807 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8808 PyObject *obj;
8809 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8810 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8811 return SWIG_Py_Void();
8812 }
8813
8814 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8815 return SWIG_Python_InitShadowInstance(args);
8816 }
8817
8818 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8819 PyObject *resultobj = 0;
8820 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8821 wxBusyCursor *result = 0 ;
8822 void *argp1 = 0 ;
8823 int res1 = 0 ;
8824 PyObject * obj0 = 0 ;
8825 char * kwnames[] = {
8826 (char *) "cursor", NULL
8827 };
8828
8829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8830 if (obj0) {
8831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8832 if (!SWIG_IsOK(res1)) {
8833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8834 }
8835 arg1 = reinterpret_cast< wxCursor * >(argp1);
8836 }
8837 {
8838 if (!wxPyCheckForApp()) SWIG_fail;
8839 PyThreadState* __tstate = wxPyBeginAllowThreads();
8840 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8841 wxPyEndAllowThreads(__tstate);
8842 if (PyErr_Occurred()) SWIG_fail;
8843 }
8844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8845 return resultobj;
8846 fail:
8847 return NULL;
8848 }
8849
8850
8851 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8852 PyObject *resultobj = 0;
8853 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8854 void *argp1 = 0 ;
8855 int res1 = 0 ;
8856 PyObject *swig_obj[1] ;
8857
8858 if (!args) SWIG_fail;
8859 swig_obj[0] = args;
8860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8861 if (!SWIG_IsOK(res1)) {
8862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8863 }
8864 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8865 {
8866 PyThreadState* __tstate = wxPyBeginAllowThreads();
8867 delete arg1;
8868
8869 wxPyEndAllowThreads(__tstate);
8870 if (PyErr_Occurred()) SWIG_fail;
8871 }
8872 resultobj = SWIG_Py_Void();
8873 return resultobj;
8874 fail:
8875 return NULL;
8876 }
8877
8878
8879 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8880 PyObject *obj;
8881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8882 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8883 return SWIG_Py_Void();
8884 }
8885
8886 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8887 return SWIG_Python_InitShadowInstance(args);
8888 }
8889
8890 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj = 0;
8892 wxWindow *arg1 = (wxWindow *) NULL ;
8893 wxWindowDisabler *result = 0 ;
8894 void *argp1 = 0 ;
8895 int res1 = 0 ;
8896 PyObject * obj0 = 0 ;
8897 char * kwnames[] = {
8898 (char *) "winToSkip", NULL
8899 };
8900
8901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8902 if (obj0) {
8903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8904 if (!SWIG_IsOK(res1)) {
8905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8906 }
8907 arg1 = reinterpret_cast< wxWindow * >(argp1);
8908 }
8909 {
8910 if (!wxPyCheckForApp()) SWIG_fail;
8911 PyThreadState* __tstate = wxPyBeginAllowThreads();
8912 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8913 wxPyEndAllowThreads(__tstate);
8914 if (PyErr_Occurred()) SWIG_fail;
8915 }
8916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8917 return resultobj;
8918 fail:
8919 return NULL;
8920 }
8921
8922
8923 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8924 PyObject *resultobj = 0;
8925 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8926 void *argp1 = 0 ;
8927 int res1 = 0 ;
8928 PyObject *swig_obj[1] ;
8929
8930 if (!args) SWIG_fail;
8931 swig_obj[0] = args;
8932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8933 if (!SWIG_IsOK(res1)) {
8934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8935 }
8936 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8937 {
8938 PyThreadState* __tstate = wxPyBeginAllowThreads();
8939 delete arg1;
8940
8941 wxPyEndAllowThreads(__tstate);
8942 if (PyErr_Occurred()) SWIG_fail;
8943 }
8944 resultobj = SWIG_Py_Void();
8945 return resultobj;
8946 fail:
8947 return NULL;
8948 }
8949
8950
8951 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8952 PyObject *obj;
8953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8954 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8955 return SWIG_Py_Void();
8956 }
8957
8958 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8959 return SWIG_Python_InitShadowInstance(args);
8960 }
8961
8962 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8963 PyObject *resultobj = 0;
8964 wxString *arg1 = 0 ;
8965 wxBusyInfo *result = 0 ;
8966 bool temp1 = false ;
8967 PyObject * obj0 = 0 ;
8968 char * kwnames[] = {
8969 (char *) "message", NULL
8970 };
8971
8972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8973 {
8974 arg1 = wxString_in_helper(obj0);
8975 if (arg1 == NULL) SWIG_fail;
8976 temp1 = true;
8977 }
8978 {
8979 if (!wxPyCheckForApp()) SWIG_fail;
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8982 wxPyEndAllowThreads(__tstate);
8983 if (PyErr_Occurred()) SWIG_fail;
8984 }
8985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8986 {
8987 if (temp1)
8988 delete arg1;
8989 }
8990 return resultobj;
8991 fail:
8992 {
8993 if (temp1)
8994 delete arg1;
8995 }
8996 return NULL;
8997 }
8998
8999
9000 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9001 PyObject *resultobj = 0;
9002 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9003 void *argp1 = 0 ;
9004 int res1 = 0 ;
9005 PyObject *swig_obj[1] ;
9006
9007 if (!args) SWIG_fail;
9008 swig_obj[0] = args;
9009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9010 if (!SWIG_IsOK(res1)) {
9011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9012 }
9013 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9014 {
9015 PyThreadState* __tstate = wxPyBeginAllowThreads();
9016 delete arg1;
9017
9018 wxPyEndAllowThreads(__tstate);
9019 if (PyErr_Occurred()) SWIG_fail;
9020 }
9021 resultobj = SWIG_Py_Void();
9022 return resultobj;
9023 fail:
9024 return NULL;
9025 }
9026
9027
9028 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9029 PyObject *obj;
9030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9031 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9032 return SWIG_Py_Void();
9033 }
9034
9035 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9036 return SWIG_Python_InitShadowInstance(args);
9037 }
9038
9039 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9040 PyObject *resultobj = 0;
9041 wxStopWatch *result = 0 ;
9042
9043 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9044 {
9045 PyThreadState* __tstate = wxPyBeginAllowThreads();
9046 result = (wxStopWatch *)new wxStopWatch();
9047 wxPyEndAllowThreads(__tstate);
9048 if (PyErr_Occurred()) SWIG_fail;
9049 }
9050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9051 return resultobj;
9052 fail:
9053 return NULL;
9054 }
9055
9056
9057 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9058 PyObject *resultobj = 0;
9059 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9060 long arg2 = (long) 0 ;
9061 void *argp1 = 0 ;
9062 int res1 = 0 ;
9063 long val2 ;
9064 int ecode2 = 0 ;
9065 PyObject * obj0 = 0 ;
9066 PyObject * obj1 = 0 ;
9067 char * kwnames[] = {
9068 (char *) "self",(char *) "t0", NULL
9069 };
9070
9071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9073 if (!SWIG_IsOK(res1)) {
9074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9075 }
9076 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9077 if (obj1) {
9078 ecode2 = SWIG_AsVal_long(obj1, &val2);
9079 if (!SWIG_IsOK(ecode2)) {
9080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9081 }
9082 arg2 = static_cast< long >(val2);
9083 }
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 (arg1)->Start(arg2);
9087 wxPyEndAllowThreads(__tstate);
9088 if (PyErr_Occurred()) SWIG_fail;
9089 }
9090 resultobj = SWIG_Py_Void();
9091 return resultobj;
9092 fail:
9093 return NULL;
9094 }
9095
9096
9097 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9098 PyObject *resultobj = 0;
9099 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9100 void *argp1 = 0 ;
9101 int res1 = 0 ;
9102 PyObject *swig_obj[1] ;
9103
9104 if (!args) SWIG_fail;
9105 swig_obj[0] = args;
9106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9107 if (!SWIG_IsOK(res1)) {
9108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9109 }
9110 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9111 {
9112 PyThreadState* __tstate = wxPyBeginAllowThreads();
9113 (arg1)->Pause();
9114 wxPyEndAllowThreads(__tstate);
9115 if (PyErr_Occurred()) SWIG_fail;
9116 }
9117 resultobj = SWIG_Py_Void();
9118 return resultobj;
9119 fail:
9120 return NULL;
9121 }
9122
9123
9124 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9125 PyObject *resultobj = 0;
9126 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9127 void *argp1 = 0 ;
9128 int res1 = 0 ;
9129 PyObject *swig_obj[1] ;
9130
9131 if (!args) SWIG_fail;
9132 swig_obj[0] = args;
9133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9134 if (!SWIG_IsOK(res1)) {
9135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9136 }
9137 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9138 {
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 (arg1)->Resume();
9141 wxPyEndAllowThreads(__tstate);
9142 if (PyErr_Occurred()) SWIG_fail;
9143 }
9144 resultobj = SWIG_Py_Void();
9145 return resultobj;
9146 fail:
9147 return NULL;
9148 }
9149
9150
9151 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9152 PyObject *resultobj = 0;
9153 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9154 long result;
9155 void *argp1 = 0 ;
9156 int res1 = 0 ;
9157 PyObject *swig_obj[1] ;
9158
9159 if (!args) SWIG_fail;
9160 swig_obj[0] = args;
9161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9162 if (!SWIG_IsOK(res1)) {
9163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9164 }
9165 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9166 {
9167 PyThreadState* __tstate = wxPyBeginAllowThreads();
9168 result = (long)((wxStopWatch const *)arg1)->Time();
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_From_long(static_cast< long >(result));
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9180 PyObject *obj;
9181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9182 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9183 return SWIG_Py_Void();
9184 }
9185
9186 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9187 return SWIG_Python_InitShadowInstance(args);
9188 }
9189
9190 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9191 PyObject *resultobj = 0;
9192 int arg1 = (int) 9 ;
9193 int arg2 = (int) wxID_FILE1 ;
9194 wxFileHistory *result = 0 ;
9195 int val1 ;
9196 int ecode1 = 0 ;
9197 int val2 ;
9198 int ecode2 = 0 ;
9199 PyObject * obj0 = 0 ;
9200 PyObject * obj1 = 0 ;
9201 char * kwnames[] = {
9202 (char *) "maxFiles",(char *) "idBase", NULL
9203 };
9204
9205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9206 if (obj0) {
9207 ecode1 = SWIG_AsVal_int(obj0, &val1);
9208 if (!SWIG_IsOK(ecode1)) {
9209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9210 }
9211 arg1 = static_cast< int >(val1);
9212 }
9213 if (obj1) {
9214 ecode2 = SWIG_AsVal_int(obj1, &val2);
9215 if (!SWIG_IsOK(ecode2)) {
9216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9217 }
9218 arg2 = static_cast< int >(val2);
9219 }
9220 {
9221 PyThreadState* __tstate = wxPyBeginAllowThreads();
9222 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234 PyObject *resultobj = 0;
9235 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9236 void *argp1 = 0 ;
9237 int res1 = 0 ;
9238 PyObject *swig_obj[1] ;
9239
9240 if (!args) SWIG_fail;
9241 swig_obj[0] = args;
9242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9245 }
9246 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 delete arg1;
9250
9251 wxPyEndAllowThreads(__tstate);
9252 if (PyErr_Occurred()) SWIG_fail;
9253 }
9254 resultobj = SWIG_Py_Void();
9255 return resultobj;
9256 fail:
9257 return NULL;
9258 }
9259
9260
9261 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9262 PyObject *resultobj = 0;
9263 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9264 wxString *arg2 = 0 ;
9265 void *argp1 = 0 ;
9266 int res1 = 0 ;
9267 bool temp2 = false ;
9268 PyObject * obj0 = 0 ;
9269 PyObject * obj1 = 0 ;
9270 char * kwnames[] = {
9271 (char *) "self",(char *) "file", NULL
9272 };
9273
9274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9276 if (!SWIG_IsOK(res1)) {
9277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9278 }
9279 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9280 {
9281 arg2 = wxString_in_helper(obj1);
9282 if (arg2 == NULL) SWIG_fail;
9283 temp2 = true;
9284 }
9285 {
9286 PyThreadState* __tstate = wxPyBeginAllowThreads();
9287 (arg1)->AddFileToHistory((wxString const &)*arg2);
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 resultobj = SWIG_Py_Void();
9292 {
9293 if (temp2)
9294 delete arg2;
9295 }
9296 return resultobj;
9297 fail:
9298 {
9299 if (temp2)
9300 delete arg2;
9301 }
9302 return NULL;
9303 }
9304
9305
9306 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj = 0;
9308 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9309 int arg2 ;
9310 void *argp1 = 0 ;
9311 int res1 = 0 ;
9312 int val2 ;
9313 int ecode2 = 0 ;
9314 PyObject * obj0 = 0 ;
9315 PyObject * obj1 = 0 ;
9316 char * kwnames[] = {
9317 (char *) "self",(char *) "i", NULL
9318 };
9319
9320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9322 if (!SWIG_IsOK(res1)) {
9323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9324 }
9325 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9326 ecode2 = SWIG_AsVal_int(obj1, &val2);
9327 if (!SWIG_IsOK(ecode2)) {
9328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9329 }
9330 arg2 = static_cast< int >(val2);
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 (arg1)->RemoveFileFromHistory(arg2);
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 resultobj = SWIG_Py_Void();
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9345 PyObject *resultobj = 0;
9346 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9347 int result;
9348 void *argp1 = 0 ;
9349 int res1 = 0 ;
9350 PyObject *swig_obj[1] ;
9351
9352 if (!args) SWIG_fail;
9353 swig_obj[0] = args;
9354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9355 if (!SWIG_IsOK(res1)) {
9356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9357 }
9358 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_From_int(static_cast< int >(result));
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9373 PyObject *resultobj = 0;
9374 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9375 wxMenu *arg2 = (wxMenu *) 0 ;
9376 void *argp1 = 0 ;
9377 int res1 = 0 ;
9378 void *argp2 = 0 ;
9379 int res2 = 0 ;
9380 PyObject * obj0 = 0 ;
9381 PyObject * obj1 = 0 ;
9382 char * kwnames[] = {
9383 (char *) "self",(char *) "menu", NULL
9384 };
9385
9386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9388 if (!SWIG_IsOK(res1)) {
9389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9390 }
9391 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9393 if (!SWIG_IsOK(res2)) {
9394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9395 }
9396 arg2 = reinterpret_cast< wxMenu * >(argp2);
9397 {
9398 PyThreadState* __tstate = wxPyBeginAllowThreads();
9399 (arg1)->UseMenu(arg2);
9400 wxPyEndAllowThreads(__tstate);
9401 if (PyErr_Occurred()) SWIG_fail;
9402 }
9403 resultobj = SWIG_Py_Void();
9404 return resultobj;
9405 fail:
9406 return NULL;
9407 }
9408
9409
9410 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9411 PyObject *resultobj = 0;
9412 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9413 wxMenu *arg2 = (wxMenu *) 0 ;
9414 void *argp1 = 0 ;
9415 int res1 = 0 ;
9416 void *argp2 = 0 ;
9417 int res2 = 0 ;
9418 PyObject * obj0 = 0 ;
9419 PyObject * obj1 = 0 ;
9420 char * kwnames[] = {
9421 (char *) "self",(char *) "menu", NULL
9422 };
9423
9424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9428 }
9429 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9430 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9431 if (!SWIG_IsOK(res2)) {
9432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9433 }
9434 arg2 = reinterpret_cast< wxMenu * >(argp2);
9435 {
9436 PyThreadState* __tstate = wxPyBeginAllowThreads();
9437 (arg1)->RemoveMenu(arg2);
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 resultobj = SWIG_Py_Void();
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9449 PyObject *resultobj = 0;
9450 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9451 wxConfigBase *arg2 = 0 ;
9452 void *argp1 = 0 ;
9453 int res1 = 0 ;
9454 void *argp2 = 0 ;
9455 int res2 = 0 ;
9456 PyObject * obj0 = 0 ;
9457 PyObject * obj1 = 0 ;
9458 char * kwnames[] = {
9459 (char *) "self",(char *) "config", NULL
9460 };
9461
9462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9464 if (!SWIG_IsOK(res1)) {
9465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9466 }
9467 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9468 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9469 if (!SWIG_IsOK(res2)) {
9470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9471 }
9472 if (!argp2) {
9473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9474 }
9475 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 (arg1)->Load(*arg2);
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_Py_Void();
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = 0;
9491 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9492 wxConfigBase *arg2 = 0 ;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 void *argp2 = 0 ;
9496 int res2 = 0 ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 char * kwnames[] = {
9500 (char *) "self",(char *) "config", NULL
9501 };
9502
9503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9505 if (!SWIG_IsOK(res1)) {
9506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9507 }
9508 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9510 if (!SWIG_IsOK(res2)) {
9511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9512 }
9513 if (!argp2) {
9514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9515 }
9516 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9517 {
9518 PyThreadState* __tstate = wxPyBeginAllowThreads();
9519 (arg1)->Save(*arg2);
9520 wxPyEndAllowThreads(__tstate);
9521 if (PyErr_Occurred()) SWIG_fail;
9522 }
9523 resultobj = SWIG_Py_Void();
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9531 PyObject *resultobj = 0;
9532 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9533 void *argp1 = 0 ;
9534 int res1 = 0 ;
9535 PyObject *swig_obj[1] ;
9536
9537 if (!args) SWIG_fail;
9538 swig_obj[0] = args;
9539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9540 if (!SWIG_IsOK(res1)) {
9541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9542 }
9543 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9544 {
9545 PyThreadState* __tstate = wxPyBeginAllowThreads();
9546 (arg1)->AddFilesToMenu();
9547 wxPyEndAllowThreads(__tstate);
9548 if (PyErr_Occurred()) SWIG_fail;
9549 }
9550 resultobj = SWIG_Py_Void();
9551 return resultobj;
9552 fail:
9553 return NULL;
9554 }
9555
9556
9557 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj = 0;
9559 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9560 wxMenu *arg2 = (wxMenu *) 0 ;
9561 void *argp1 = 0 ;
9562 int res1 = 0 ;
9563 void *argp2 = 0 ;
9564 int res2 = 0 ;
9565 PyObject * obj0 = 0 ;
9566 PyObject * obj1 = 0 ;
9567 char * kwnames[] = {
9568 (char *) "self",(char *) "menu", NULL
9569 };
9570
9571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9573 if (!SWIG_IsOK(res1)) {
9574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9575 }
9576 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9578 if (!SWIG_IsOK(res2)) {
9579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9580 }
9581 arg2 = reinterpret_cast< wxMenu * >(argp2);
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 (arg1)->AddFilesToMenu(arg2);
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_Py_Void();
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj = 0;
9597 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9598 int arg2 ;
9599 wxString result;
9600 void *argp1 = 0 ;
9601 int res1 = 0 ;
9602 int val2 ;
9603 int ecode2 = 0 ;
9604 PyObject * obj0 = 0 ;
9605 PyObject * obj1 = 0 ;
9606 char * kwnames[] = {
9607 (char *) "self",(char *) "i", NULL
9608 };
9609
9610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9612 if (!SWIG_IsOK(res1)) {
9613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9614 }
9615 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9616 ecode2 = SWIG_AsVal_int(obj1, &val2);
9617 if (!SWIG_IsOK(ecode2)) {
9618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9619 }
9620 arg2 = static_cast< int >(val2);
9621 {
9622 PyThreadState* __tstate = wxPyBeginAllowThreads();
9623 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9624 wxPyEndAllowThreads(__tstate);
9625 if (PyErr_Occurred()) SWIG_fail;
9626 }
9627 {
9628 #if wxUSE_UNICODE
9629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9630 #else
9631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9632 #endif
9633 }
9634 return resultobj;
9635 fail:
9636 return NULL;
9637 }
9638
9639
9640 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9641 PyObject *resultobj = 0;
9642 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9643 int result;
9644 void *argp1 = 0 ;
9645 int res1 = 0 ;
9646 PyObject *swig_obj[1] ;
9647
9648 if (!args) SWIG_fail;
9649 swig_obj[0] = args;
9650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9651 if (!SWIG_IsOK(res1)) {
9652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9653 }
9654 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (int)((wxFileHistory const *)arg1)->GetCount();
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_From_int(static_cast< int >(result));
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9669 PyObject *obj;
9670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9671 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9672 return SWIG_Py_Void();
9673 }
9674
9675 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9676 return SWIG_Python_InitShadowInstance(args);
9677 }
9678
9679 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9680 PyObject *resultobj = 0;
9681 wxString *arg1 = 0 ;
9682 wxString const &arg2_defvalue = wxPyEmptyString ;
9683 wxString *arg2 = (wxString *) &arg2_defvalue ;
9684 wxSingleInstanceChecker *result = 0 ;
9685 bool temp1 = false ;
9686 bool temp2 = false ;
9687 PyObject * obj0 = 0 ;
9688 PyObject * obj1 = 0 ;
9689 char * kwnames[] = {
9690 (char *) "name",(char *) "path", NULL
9691 };
9692
9693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9694 {
9695 arg1 = wxString_in_helper(obj0);
9696 if (arg1 == NULL) SWIG_fail;
9697 temp1 = true;
9698 }
9699 if (obj1) {
9700 {
9701 arg2 = wxString_in_helper(obj1);
9702 if (arg2 == NULL) SWIG_fail;
9703 temp2 = true;
9704 }
9705 }
9706 {
9707 PyThreadState* __tstate = wxPyBeginAllowThreads();
9708 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9713 {
9714 if (temp1)
9715 delete arg1;
9716 }
9717 {
9718 if (temp2)
9719 delete arg2;
9720 }
9721 return resultobj;
9722 fail:
9723 {
9724 if (temp1)
9725 delete arg1;
9726 }
9727 {
9728 if (temp2)
9729 delete arg2;
9730 }
9731 return NULL;
9732 }
9733
9734
9735 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9736 PyObject *resultobj = 0;
9737 wxSingleInstanceChecker *result = 0 ;
9738
9739 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9740 {
9741 PyThreadState* __tstate = wxPyBeginAllowThreads();
9742 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9743 wxPyEndAllowThreads(__tstate);
9744 if (PyErr_Occurred()) SWIG_fail;
9745 }
9746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9747 return resultobj;
9748 fail:
9749 return NULL;
9750 }
9751
9752
9753 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9754 PyObject *resultobj = 0;
9755 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9756 void *argp1 = 0 ;
9757 int res1 = 0 ;
9758 PyObject *swig_obj[1] ;
9759
9760 if (!args) SWIG_fail;
9761 swig_obj[0] = args;
9762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9763 if (!SWIG_IsOK(res1)) {
9764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9765 }
9766 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 delete arg1;
9770
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 resultobj = SWIG_Py_Void();
9775 return resultobj;
9776 fail:
9777 return NULL;
9778 }
9779
9780
9781 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj = 0;
9783 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9784 wxString *arg2 = 0 ;
9785 wxString const &arg3_defvalue = wxPyEmptyString ;
9786 wxString *arg3 = (wxString *) &arg3_defvalue ;
9787 bool result;
9788 void *argp1 = 0 ;
9789 int res1 = 0 ;
9790 bool temp2 = false ;
9791 bool temp3 = false ;
9792 PyObject * obj0 = 0 ;
9793 PyObject * obj1 = 0 ;
9794 PyObject * obj2 = 0 ;
9795 char * kwnames[] = {
9796 (char *) "self",(char *) "name",(char *) "path", NULL
9797 };
9798
9799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9801 if (!SWIG_IsOK(res1)) {
9802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9803 }
9804 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9805 {
9806 arg2 = wxString_in_helper(obj1);
9807 if (arg2 == NULL) SWIG_fail;
9808 temp2 = true;
9809 }
9810 if (obj2) {
9811 {
9812 arg3 = wxString_in_helper(obj2);
9813 if (arg3 == NULL) SWIG_fail;
9814 temp3 = true;
9815 }
9816 }
9817 {
9818 PyThreadState* __tstate = wxPyBeginAllowThreads();
9819 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 {
9824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9825 }
9826 {
9827 if (temp2)
9828 delete arg2;
9829 }
9830 {
9831 if (temp3)
9832 delete arg3;
9833 }
9834 return resultobj;
9835 fail:
9836 {
9837 if (temp2)
9838 delete arg2;
9839 }
9840 {
9841 if (temp3)
9842 delete arg3;
9843 }
9844 return NULL;
9845 }
9846
9847
9848 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9849 PyObject *resultobj = 0;
9850 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9851 bool result;
9852 void *argp1 = 0 ;
9853 int res1 = 0 ;
9854 PyObject *swig_obj[1] ;
9855
9856 if (!args) SWIG_fail;
9857 swig_obj[0] = args;
9858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9859 if (!SWIG_IsOK(res1)) {
9860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9861 }
9862 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9863 {
9864 PyThreadState* __tstate = wxPyBeginAllowThreads();
9865 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9866 wxPyEndAllowThreads(__tstate);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 {
9870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9871 }
9872 return resultobj;
9873 fail:
9874 return NULL;
9875 }
9876
9877
9878 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9879 PyObject *obj;
9880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9881 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9882 return SWIG_Py_Void();
9883 }
9884
9885 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9886 return SWIG_Python_InitShadowInstance(args);
9887 }
9888
9889 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9890 PyObject *resultobj = 0;
9891 wxWindow *arg1 = (wxWindow *) 0 ;
9892 wxDC *arg2 = 0 ;
9893 bool result;
9894 void *argp1 = 0 ;
9895 int res1 = 0 ;
9896 void *argp2 = 0 ;
9897 int res2 = 0 ;
9898 PyObject * obj0 = 0 ;
9899 PyObject * obj1 = 0 ;
9900 char * kwnames[] = {
9901 (char *) "window",(char *) "dc", NULL
9902 };
9903
9904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9906 if (!SWIG_IsOK(res1)) {
9907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9908 }
9909 arg1 = reinterpret_cast< wxWindow * >(argp1);
9910 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9911 if (!SWIG_IsOK(res2)) {
9912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9913 }
9914 if (!argp2) {
9915 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9916 }
9917 arg2 = reinterpret_cast< wxDC * >(argp2);
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 {
9925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9926 }
9927 return resultobj;
9928 fail:
9929 return NULL;
9930 }
9931
9932
9933 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9934 PyObject *resultobj = 0;
9935 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9936 void *argp1 = 0 ;
9937 int res1 = 0 ;
9938 PyObject *swig_obj[1] ;
9939
9940 if (!args) SWIG_fail;
9941 swig_obj[0] = args;
9942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9943 if (!SWIG_IsOK(res1)) {
9944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9945 }
9946 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9947 {
9948 PyThreadState* __tstate = wxPyBeginAllowThreads();
9949 delete arg1;
9950
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 resultobj = SWIG_Py_Void();
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9962 PyObject *resultobj = 0;
9963 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9964 wxString result;
9965 void *argp1 = 0 ;
9966 int res1 = 0 ;
9967 PyObject *swig_obj[1] ;
9968
9969 if (!args) SWIG_fail;
9970 swig_obj[0] = args;
9971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9972 if (!SWIG_IsOK(res1)) {
9973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9974 }
9975 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9976 {
9977 PyThreadState* __tstate = wxPyBeginAllowThreads();
9978 result = (arg1)->GetTip();
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 {
9983 #if wxUSE_UNICODE
9984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9985 #else
9986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9987 #endif
9988 }
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9996 PyObject *resultobj = 0;
9997 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9998 size_t result;
9999 void *argp1 = 0 ;
10000 int res1 = 0 ;
10001 PyObject *swig_obj[1] ;
10002
10003 if (!args) SWIG_fail;
10004 swig_obj[0] = args;
10005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10006 if (!SWIG_IsOK(res1)) {
10007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10008 }
10009 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 result = (size_t)(arg1)->GetCurrentTip();
10013 wxPyEndAllowThreads(__tstate);
10014 if (PyErr_Occurred()) SWIG_fail;
10015 }
10016 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10017 return resultobj;
10018 fail:
10019 return NULL;
10020 }
10021
10022
10023 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10024 PyObject *resultobj = 0;
10025 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10026 wxString *arg2 = 0 ;
10027 wxString result;
10028 void *argp1 = 0 ;
10029 int res1 = 0 ;
10030 bool temp2 = false ;
10031 PyObject * obj0 = 0 ;
10032 PyObject * obj1 = 0 ;
10033 char * kwnames[] = {
10034 (char *) "self",(char *) "tip", NULL
10035 };
10036
10037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10039 if (!SWIG_IsOK(res1)) {
10040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10041 }
10042 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10043 {
10044 arg2 = wxString_in_helper(obj1);
10045 if (arg2 == NULL) SWIG_fail;
10046 temp2 = true;
10047 }
10048 {
10049 PyThreadState* __tstate = wxPyBeginAllowThreads();
10050 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10051 wxPyEndAllowThreads(__tstate);
10052 if (PyErr_Occurred()) SWIG_fail;
10053 }
10054 {
10055 #if wxUSE_UNICODE
10056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10057 #else
10058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10059 #endif
10060 }
10061 {
10062 if (temp2)
10063 delete arg2;
10064 }
10065 return resultobj;
10066 fail:
10067 {
10068 if (temp2)
10069 delete arg2;
10070 }
10071 return NULL;
10072 }
10073
10074
10075 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10076 PyObject *obj;
10077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10078 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10079 return SWIG_Py_Void();
10080 }
10081
10082 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10083 PyObject *resultobj = 0;
10084 size_t arg1 ;
10085 wxPyTipProvider *result = 0 ;
10086 size_t val1 ;
10087 int ecode1 = 0 ;
10088 PyObject * obj0 = 0 ;
10089 char * kwnames[] = {
10090 (char *) "currentTip", NULL
10091 };
10092
10093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10094 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10095 if (!SWIG_IsOK(ecode1)) {
10096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10097 }
10098 arg1 = static_cast< size_t >(val1);
10099 {
10100 PyThreadState* __tstate = wxPyBeginAllowThreads();
10101 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10102 wxPyEndAllowThreads(__tstate);
10103 if (PyErr_Occurred()) SWIG_fail;
10104 }
10105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10106 return resultobj;
10107 fail:
10108 return NULL;
10109 }
10110
10111
10112 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10113 PyObject *resultobj = 0;
10114 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10115 PyObject *arg2 = (PyObject *) 0 ;
10116 PyObject *arg3 = (PyObject *) 0 ;
10117 void *argp1 = 0 ;
10118 int res1 = 0 ;
10119 PyObject * obj0 = 0 ;
10120 PyObject * obj1 = 0 ;
10121 PyObject * obj2 = 0 ;
10122 char * kwnames[] = {
10123 (char *) "self",(char *) "self",(char *) "_class", NULL
10124 };
10125
10126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10128 if (!SWIG_IsOK(res1)) {
10129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10130 }
10131 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10132 arg2 = obj1;
10133 arg3 = obj2;
10134 {
10135 PyThreadState* __tstate = wxPyBeginAllowThreads();
10136 (arg1)->_setCallbackInfo(arg2,arg3);
10137 wxPyEndAllowThreads(__tstate);
10138 if (PyErr_Occurred()) SWIG_fail;
10139 }
10140 resultobj = SWIG_Py_Void();
10141 return resultobj;
10142 fail:
10143 return NULL;
10144 }
10145
10146
10147 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10148 PyObject *obj;
10149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10150 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10151 return SWIG_Py_Void();
10152 }
10153
10154 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10155 return SWIG_Python_InitShadowInstance(args);
10156 }
10157
10158 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj = 0;
10160 wxWindow *arg1 = (wxWindow *) 0 ;
10161 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10162 bool arg3 = (bool) true ;
10163 bool result;
10164 void *argp1 = 0 ;
10165 int res1 = 0 ;
10166 void *argp2 = 0 ;
10167 int res2 = 0 ;
10168 bool val3 ;
10169 int ecode3 = 0 ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 PyObject * obj2 = 0 ;
10173 char * kwnames[] = {
10174 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10175 };
10176
10177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10179 if (!SWIG_IsOK(res1)) {
10180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10181 }
10182 arg1 = reinterpret_cast< wxWindow * >(argp1);
10183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10184 if (!SWIG_IsOK(res2)) {
10185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10186 }
10187 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10188 if (obj2) {
10189 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10190 if (!SWIG_IsOK(ecode3)) {
10191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10192 }
10193 arg3 = static_cast< bool >(val3);
10194 }
10195 {
10196 if (!wxPyCheckForApp()) SWIG_fail;
10197 PyThreadState* __tstate = wxPyBeginAllowThreads();
10198 result = (bool)wxShowTip(arg1,arg2,arg3);
10199 wxPyEndAllowThreads(__tstate);
10200 if (PyErr_Occurred()) SWIG_fail;
10201 }
10202 {
10203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10204 }
10205 return resultobj;
10206 fail:
10207 return NULL;
10208 }
10209
10210
10211 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj = 0;
10213 wxString *arg1 = 0 ;
10214 size_t arg2 ;
10215 wxTipProvider *result = 0 ;
10216 bool temp1 = false ;
10217 size_t val2 ;
10218 int ecode2 = 0 ;
10219 PyObject * obj0 = 0 ;
10220 PyObject * obj1 = 0 ;
10221 char * kwnames[] = {
10222 (char *) "filename",(char *) "currentTip", NULL
10223 };
10224
10225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10226 {
10227 arg1 = wxString_in_helper(obj0);
10228 if (arg1 == NULL) SWIG_fail;
10229 temp1 = true;
10230 }
10231 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10232 if (!SWIG_IsOK(ecode2)) {
10233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10234 }
10235 arg2 = static_cast< size_t >(val2);
10236 {
10237 if (!wxPyCheckForApp()) SWIG_fail;
10238 PyThreadState* __tstate = wxPyBeginAllowThreads();
10239 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10240 wxPyEndAllowThreads(__tstate);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10244 {
10245 if (temp1)
10246 delete arg1;
10247 }
10248 return resultobj;
10249 fail:
10250 {
10251 if (temp1)
10252 delete arg1;
10253 }
10254 return NULL;
10255 }
10256
10257
10258 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10259 PyObject *resultobj = 0;
10260 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10261 int arg2 = (int) wxID_ANY ;
10262 wxPyTimer *result = 0 ;
10263 void *argp1 = 0 ;
10264 int res1 = 0 ;
10265 int val2 ;
10266 int ecode2 = 0 ;
10267 PyObject * obj0 = 0 ;
10268 PyObject * obj1 = 0 ;
10269 char * kwnames[] = {
10270 (char *) "owner",(char *) "id", NULL
10271 };
10272
10273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10274 if (obj0) {
10275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10276 if (!SWIG_IsOK(res1)) {
10277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10278 }
10279 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10280 }
10281 if (obj1) {
10282 ecode2 = SWIG_AsVal_int(obj1, &val2);
10283 if (!SWIG_IsOK(ecode2)) {
10284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10285 }
10286 arg2 = static_cast< int >(val2);
10287 }
10288 {
10289 if (!wxPyCheckForApp()) SWIG_fail;
10290 PyThreadState* __tstate = wxPyBeginAllowThreads();
10291 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10292 wxPyEndAllowThreads(__tstate);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10296 return resultobj;
10297 fail:
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10303 PyObject *resultobj = 0;
10304 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10305 void *argp1 = 0 ;
10306 int res1 = 0 ;
10307 PyObject *swig_obj[1] ;
10308
10309 if (!args) SWIG_fail;
10310 swig_obj[0] = args;
10311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10312 if (!SWIG_IsOK(res1)) {
10313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10314 }
10315 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 delete arg1;
10319
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 resultobj = SWIG_Py_Void();
10324 return resultobj;
10325 fail:
10326 return NULL;
10327 }
10328
10329
10330 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10331 PyObject *resultobj = 0;
10332 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10333 PyObject *arg2 = (PyObject *) 0 ;
10334 PyObject *arg3 = (PyObject *) 0 ;
10335 int arg4 = (int) 1 ;
10336 void *argp1 = 0 ;
10337 int res1 = 0 ;
10338 int val4 ;
10339 int ecode4 = 0 ;
10340 PyObject * obj0 = 0 ;
10341 PyObject * obj1 = 0 ;
10342 PyObject * obj2 = 0 ;
10343 PyObject * obj3 = 0 ;
10344 char * kwnames[] = {
10345 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10346 };
10347
10348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10350 if (!SWIG_IsOK(res1)) {
10351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10352 }
10353 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10354 arg2 = obj1;
10355 arg3 = obj2;
10356 if (obj3) {
10357 ecode4 = SWIG_AsVal_int(obj3, &val4);
10358 if (!SWIG_IsOK(ecode4)) {
10359 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10360 }
10361 arg4 = static_cast< int >(val4);
10362 }
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 resultobj = SWIG_Py_Void();
10370 return resultobj;
10371 fail:
10372 return NULL;
10373 }
10374
10375
10376 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10377 PyObject *resultobj = 0;
10378 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10379 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10380 int arg3 = (int) wxID_ANY ;
10381 void *argp1 = 0 ;
10382 int res1 = 0 ;
10383 void *argp2 = 0 ;
10384 int res2 = 0 ;
10385 int val3 ;
10386 int ecode3 = 0 ;
10387 PyObject * obj0 = 0 ;
10388 PyObject * obj1 = 0 ;
10389 PyObject * obj2 = 0 ;
10390 char * kwnames[] = {
10391 (char *) "self",(char *) "owner",(char *) "id", NULL
10392 };
10393
10394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10396 if (!SWIG_IsOK(res1)) {
10397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10398 }
10399 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10401 if (!SWIG_IsOK(res2)) {
10402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10403 }
10404 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10405 if (obj2) {
10406 ecode3 = SWIG_AsVal_int(obj2, &val3);
10407 if (!SWIG_IsOK(ecode3)) {
10408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10409 }
10410 arg3 = static_cast< int >(val3);
10411 }
10412 {
10413 PyThreadState* __tstate = wxPyBeginAllowThreads();
10414 (arg1)->SetOwner(arg2,arg3);
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 resultobj = SWIG_Py_Void();
10419 return resultobj;
10420 fail:
10421 return NULL;
10422 }
10423
10424
10425 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10426 PyObject *resultobj = 0;
10427 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10428 wxEvtHandler *result = 0 ;
10429 void *argp1 = 0 ;
10430 int res1 = 0 ;
10431 PyObject *swig_obj[1] ;
10432
10433 if (!args) SWIG_fail;
10434 swig_obj[0] = args;
10435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10436 if (!SWIG_IsOK(res1)) {
10437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10438 }
10439 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10440 {
10441 PyThreadState* __tstate = wxPyBeginAllowThreads();
10442 result = (wxEvtHandler *)(arg1)->GetOwner();
10443 wxPyEndAllowThreads(__tstate);
10444 if (PyErr_Occurred()) SWIG_fail;
10445 }
10446 {
10447 resultobj = wxPyMake_wxObject(result, 0);
10448 }
10449 return resultobj;
10450 fail:
10451 return NULL;
10452 }
10453
10454
10455 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10456 PyObject *resultobj = 0;
10457 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10458 int arg2 = (int) -1 ;
10459 bool arg3 = (bool) false ;
10460 bool result;
10461 void *argp1 = 0 ;
10462 int res1 = 0 ;
10463 int val2 ;
10464 int ecode2 = 0 ;
10465 bool val3 ;
10466 int ecode3 = 0 ;
10467 PyObject * obj0 = 0 ;
10468 PyObject * obj1 = 0 ;
10469 PyObject * obj2 = 0 ;
10470 char * kwnames[] = {
10471 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10472 };
10473
10474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10476 if (!SWIG_IsOK(res1)) {
10477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10478 }
10479 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10480 if (obj1) {
10481 ecode2 = SWIG_AsVal_int(obj1, &val2);
10482 if (!SWIG_IsOK(ecode2)) {
10483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10484 }
10485 arg2 = static_cast< int >(val2);
10486 }
10487 if (obj2) {
10488 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10489 if (!SWIG_IsOK(ecode3)) {
10490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10491 }
10492 arg3 = static_cast< bool >(val3);
10493 }
10494 {
10495 PyThreadState* __tstate = wxPyBeginAllowThreads();
10496 result = (bool)(arg1)->Start(arg2,arg3);
10497 wxPyEndAllowThreads(__tstate);
10498 if (PyErr_Occurred()) SWIG_fail;
10499 }
10500 {
10501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10502 }
10503 return resultobj;
10504 fail:
10505 return NULL;
10506 }
10507
10508
10509 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10510 PyObject *resultobj = 0;
10511 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10512 void *argp1 = 0 ;
10513 int res1 = 0 ;
10514 PyObject *swig_obj[1] ;
10515
10516 if (!args) SWIG_fail;
10517 swig_obj[0] = args;
10518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10519 if (!SWIG_IsOK(res1)) {
10520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10521 }
10522 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10523 {
10524 PyThreadState* __tstate = wxPyBeginAllowThreads();
10525 (arg1)->Stop();
10526 wxPyEndAllowThreads(__tstate);
10527 if (PyErr_Occurred()) SWIG_fail;
10528 }
10529 resultobj = SWIG_Py_Void();
10530 return resultobj;
10531 fail:
10532 return NULL;
10533 }
10534
10535
10536 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10537 PyObject *resultobj = 0;
10538 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10539 void *argp1 = 0 ;
10540 int res1 = 0 ;
10541 PyObject *swig_obj[1] ;
10542
10543 if (!args) SWIG_fail;
10544 swig_obj[0] = args;
10545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10546 if (!SWIG_IsOK(res1)) {
10547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10548 }
10549 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10550 {
10551 PyThreadState* __tstate = wxPyBeginAllowThreads();
10552 (arg1)->Notify();
10553 wxPyEndAllowThreads(__tstate);
10554 if (PyErr_Occurred()) SWIG_fail;
10555 }
10556 resultobj = SWIG_Py_Void();
10557 return resultobj;
10558 fail:
10559 return NULL;
10560 }
10561
10562
10563 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10564 PyObject *resultobj = 0;
10565 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10566 bool result;
10567 void *argp1 = 0 ;
10568 int res1 = 0 ;
10569 PyObject *swig_obj[1] ;
10570
10571 if (!args) SWIG_fail;
10572 swig_obj[0] = args;
10573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10574 if (!SWIG_IsOK(res1)) {
10575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10576 }
10577 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10578 {
10579 PyThreadState* __tstate = wxPyBeginAllowThreads();
10580 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10581 wxPyEndAllowThreads(__tstate);
10582 if (PyErr_Occurred()) SWIG_fail;
10583 }
10584 {
10585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10586 }
10587 return resultobj;
10588 fail:
10589 return NULL;
10590 }
10591
10592
10593 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10594 PyObject *resultobj = 0;
10595 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10596 int result;
10597 void *argp1 = 0 ;
10598 int res1 = 0 ;
10599 PyObject *swig_obj[1] ;
10600
10601 if (!args) SWIG_fail;
10602 swig_obj[0] = args;
10603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10604 if (!SWIG_IsOK(res1)) {
10605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10606 }
10607 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10608 {
10609 PyThreadState* __tstate = wxPyBeginAllowThreads();
10610 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10611 wxPyEndAllowThreads(__tstate);
10612 if (PyErr_Occurred()) SWIG_fail;
10613 }
10614 resultobj = SWIG_From_int(static_cast< int >(result));
10615 return resultobj;
10616 fail:
10617 return NULL;
10618 }
10619
10620
10621 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10622 PyObject *resultobj = 0;
10623 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10624 int result;
10625 void *argp1 = 0 ;
10626 int res1 = 0 ;
10627 PyObject *swig_obj[1] ;
10628
10629 if (!args) SWIG_fail;
10630 swig_obj[0] = args;
10631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10632 if (!SWIG_IsOK(res1)) {
10633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10634 }
10635 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10636 {
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 result = (int)((wxPyTimer const *)arg1)->GetId();
10639 wxPyEndAllowThreads(__tstate);
10640 if (PyErr_Occurred()) SWIG_fail;
10641 }
10642 resultobj = SWIG_From_int(static_cast< int >(result));
10643 return resultobj;
10644 fail:
10645 return NULL;
10646 }
10647
10648
10649 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10650 PyObject *resultobj = 0;
10651 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10652 bool result;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 PyObject *swig_obj[1] ;
10656
10657 if (!args) SWIG_fail;
10658 swig_obj[0] = args;
10659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10660 if (!SWIG_IsOK(res1)) {
10661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10662 }
10663 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10672 }
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10680 PyObject *obj;
10681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10682 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10683 return SWIG_Py_Void();
10684 }
10685
10686 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10687 return SWIG_Python_InitShadowInstance(args);
10688 }
10689
10690 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj = 0;
10692 int arg1 = (int) 0 ;
10693 int arg2 = (int) 0 ;
10694 wxTimerEvent *result = 0 ;
10695 int val1 ;
10696 int ecode1 = 0 ;
10697 int val2 ;
10698 int ecode2 = 0 ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 char * kwnames[] = {
10702 (char *) "timerid",(char *) "interval", NULL
10703 };
10704
10705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10706 if (obj0) {
10707 ecode1 = SWIG_AsVal_int(obj0, &val1);
10708 if (!SWIG_IsOK(ecode1)) {
10709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10710 }
10711 arg1 = static_cast< int >(val1);
10712 }
10713 if (obj1) {
10714 ecode2 = SWIG_AsVal_int(obj1, &val2);
10715 if (!SWIG_IsOK(ecode2)) {
10716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10717 }
10718 arg2 = static_cast< int >(val2);
10719 }
10720 {
10721 PyThreadState* __tstate = wxPyBeginAllowThreads();
10722 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10723 wxPyEndAllowThreads(__tstate);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10727 return resultobj;
10728 fail:
10729 return NULL;
10730 }
10731
10732
10733 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10734 PyObject *resultobj = 0;
10735 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10736 int result;
10737 void *argp1 = 0 ;
10738 int res1 = 0 ;
10739 PyObject *swig_obj[1] ;
10740
10741 if (!args) SWIG_fail;
10742 swig_obj[0] = args;
10743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10744 if (!SWIG_IsOK(res1)) {
10745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10746 }
10747 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10748 {
10749 PyThreadState* __tstate = wxPyBeginAllowThreads();
10750 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10751 wxPyEndAllowThreads(__tstate);
10752 if (PyErr_Occurred()) SWIG_fail;
10753 }
10754 resultobj = SWIG_From_int(static_cast< int >(result));
10755 return resultobj;
10756 fail:
10757 return NULL;
10758 }
10759
10760
10761 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10762 PyObject *obj;
10763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10764 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10765 return SWIG_Py_Void();
10766 }
10767
10768 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10769 return SWIG_Python_InitShadowInstance(args);
10770 }
10771
10772 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10773 PyObject *resultobj = 0;
10774 wxTimer *arg1 = 0 ;
10775 wxTimerRunner *result = 0 ;
10776 void *argp1 = 0 ;
10777 int res1 = 0 ;
10778
10779 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10781 if (!SWIG_IsOK(res1)) {
10782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10783 }
10784 if (!argp1) {
10785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10786 }
10787 arg1 = reinterpret_cast< wxTimer * >(argp1);
10788 {
10789 if (!wxPyCheckForApp()) SWIG_fail;
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10796 return resultobj;
10797 fail:
10798 return NULL;
10799 }
10800
10801
10802 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10803 PyObject *resultobj = 0;
10804 wxTimer *arg1 = 0 ;
10805 int arg2 ;
10806 bool arg3 = (bool) false ;
10807 wxTimerRunner *result = 0 ;
10808 void *argp1 = 0 ;
10809 int res1 = 0 ;
10810 int val2 ;
10811 int ecode2 = 0 ;
10812 bool val3 ;
10813 int ecode3 = 0 ;
10814
10815 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10817 if (!SWIG_IsOK(res1)) {
10818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10819 }
10820 if (!argp1) {
10821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10822 }
10823 arg1 = reinterpret_cast< wxTimer * >(argp1);
10824 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10825 if (!SWIG_IsOK(ecode2)) {
10826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10827 }
10828 arg2 = static_cast< int >(val2);
10829 if (swig_obj[2]) {
10830 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10831 if (!SWIG_IsOK(ecode3)) {
10832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10833 }
10834 arg3 = static_cast< bool >(val3);
10835 }
10836 {
10837 if (!wxPyCheckForApp()) SWIG_fail;
10838 PyThreadState* __tstate = wxPyBeginAllowThreads();
10839 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10840 wxPyEndAllowThreads(__tstate);
10841 if (PyErr_Occurred()) SWIG_fail;
10842 }
10843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10844 return resultobj;
10845 fail:
10846 return NULL;
10847 }
10848
10849
10850 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10851 int argc;
10852 PyObject *argv[4];
10853
10854 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10855 --argc;
10856 if (argc == 1) {
10857 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10858 }
10859 if ((argc >= 2) && (argc <= 3)) {
10860 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10861 }
10862
10863 fail:
10864 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10865 return NULL;
10866 }
10867
10868
10869 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10870 PyObject *resultobj = 0;
10871 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10872 void *argp1 = 0 ;
10873 int res1 = 0 ;
10874 PyObject *swig_obj[1] ;
10875
10876 if (!args) SWIG_fail;
10877 swig_obj[0] = args;
10878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10879 if (!SWIG_IsOK(res1)) {
10880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10881 }
10882 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10883 {
10884 PyThreadState* __tstate = wxPyBeginAllowThreads();
10885 delete arg1;
10886
10887 wxPyEndAllowThreads(__tstate);
10888 if (PyErr_Occurred()) SWIG_fail;
10889 }
10890 resultobj = SWIG_Py_Void();
10891 return resultobj;
10892 fail:
10893 return NULL;
10894 }
10895
10896
10897 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10898 PyObject *resultobj = 0;
10899 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10900 int arg2 ;
10901 bool arg3 = (bool) false ;
10902 void *argp1 = 0 ;
10903 int res1 = 0 ;
10904 int val2 ;
10905 int ecode2 = 0 ;
10906 bool val3 ;
10907 int ecode3 = 0 ;
10908 PyObject * obj0 = 0 ;
10909 PyObject * obj1 = 0 ;
10910 PyObject * obj2 = 0 ;
10911 char * kwnames[] = {
10912 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10913 };
10914
10915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10917 if (!SWIG_IsOK(res1)) {
10918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10919 }
10920 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10921 ecode2 = SWIG_AsVal_int(obj1, &val2);
10922 if (!SWIG_IsOK(ecode2)) {
10923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10924 }
10925 arg2 = static_cast< int >(val2);
10926 if (obj2) {
10927 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10928 if (!SWIG_IsOK(ecode3)) {
10929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10930 }
10931 arg3 = static_cast< bool >(val3);
10932 }
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 (arg1)->Start(arg2,arg3);
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_Py_Void();
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10947 PyObject *obj;
10948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10949 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10950 return SWIG_Py_Void();
10951 }
10952
10953 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10954 return SWIG_Python_InitShadowInstance(args);
10955 }
10956
10957 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10958 PyObject *resultobj = 0;
10959 wxLog *result = 0 ;
10960
10961 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10962 {
10963 PyThreadState* __tstate = wxPyBeginAllowThreads();
10964 result = (wxLog *)new wxLog();
10965 wxPyEndAllowThreads(__tstate);
10966 if (PyErr_Occurred()) SWIG_fail;
10967 }
10968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10969 return resultobj;
10970 fail:
10971 return NULL;
10972 }
10973
10974
10975 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10976 PyObject *resultobj = 0;
10977 wxLog *arg1 = (wxLog *) 0 ;
10978 void *argp1 = 0 ;
10979 int res1 = 0 ;
10980 PyObject *swig_obj[1] ;
10981
10982 if (!args) SWIG_fail;
10983 swig_obj[0] = args;
10984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10985 if (!SWIG_IsOK(res1)) {
10986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10987 }
10988 arg1 = reinterpret_cast< wxLog * >(argp1);
10989 {
10990 PyThreadState* __tstate = wxPyBeginAllowThreads();
10991 delete arg1;
10992
10993 wxPyEndAllowThreads(__tstate);
10994 if (PyErr_Occurred()) SWIG_fail;
10995 }
10996 resultobj = SWIG_Py_Void();
10997 return resultobj;
10998 fail:
10999 return NULL;
11000 }
11001
11002
11003 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004 PyObject *resultobj = 0;
11005 bool result;
11006
11007 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11008 {
11009 PyThreadState* __tstate = wxPyBeginAllowThreads();
11010 result = (bool)wxLog::IsEnabled();
11011 wxPyEndAllowThreads(__tstate);
11012 if (PyErr_Occurred()) SWIG_fail;
11013 }
11014 {
11015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11016 }
11017 return resultobj;
11018 fail:
11019 return NULL;
11020 }
11021
11022
11023 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj = 0;
11025 bool arg1 = (bool) true ;
11026 bool result;
11027 bool val1 ;
11028 int ecode1 = 0 ;
11029 PyObject * obj0 = 0 ;
11030 char * kwnames[] = {
11031 (char *) "doIt", NULL
11032 };
11033
11034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11035 if (obj0) {
11036 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11037 if (!SWIG_IsOK(ecode1)) {
11038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11039 }
11040 arg1 = static_cast< bool >(val1);
11041 }
11042 {
11043 PyThreadState* __tstate = wxPyBeginAllowThreads();
11044 result = (bool)wxLog::EnableLogging(arg1);
11045 wxPyEndAllowThreads(__tstate);
11046 if (PyErr_Occurred()) SWIG_fail;
11047 }
11048 {
11049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11050 }
11051 return resultobj;
11052 fail:
11053 return NULL;
11054 }
11055
11056
11057 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11058 PyObject *resultobj = 0;
11059 wxLogLevel arg1 ;
11060 wxChar *arg2 = (wxChar *) 0 ;
11061 time_t arg3 ;
11062 unsigned long val1 ;
11063 int ecode1 = 0 ;
11064 void *argp2 = 0 ;
11065 int res2 = 0 ;
11066 unsigned int val3 ;
11067 int ecode3 = 0 ;
11068 PyObject * obj0 = 0 ;
11069 PyObject * obj1 = 0 ;
11070 PyObject * obj2 = 0 ;
11071 char * kwnames[] = {
11072 (char *) "level",(char *) "szString",(char *) "t", NULL
11073 };
11074
11075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11076 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11077 if (!SWIG_IsOK(ecode1)) {
11078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11079 }
11080 arg1 = static_cast< wxLogLevel >(val1);
11081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11082 if (!SWIG_IsOK(res2)) {
11083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11084 }
11085 arg2 = reinterpret_cast< wxChar * >(argp2);
11086 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11087 if (!SWIG_IsOK(ecode3)) {
11088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11089 }
11090 arg3 = static_cast< time_t >(val3);
11091 {
11092 PyThreadState* __tstate = wxPyBeginAllowThreads();
11093 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 resultobj = SWIG_Py_Void();
11098 return resultobj;
11099 fail:
11100 return NULL;
11101 }
11102
11103
11104 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11105 PyObject *resultobj = 0;
11106 wxLog *arg1 = (wxLog *) 0 ;
11107 void *argp1 = 0 ;
11108 int res1 = 0 ;
11109 PyObject *swig_obj[1] ;
11110
11111 if (!args) SWIG_fail;
11112 swig_obj[0] = args;
11113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11114 if (!SWIG_IsOK(res1)) {
11115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11116 }
11117 arg1 = reinterpret_cast< wxLog * >(argp1);
11118 {
11119 PyThreadState* __tstate = wxPyBeginAllowThreads();
11120 (arg1)->Flush();
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 resultobj = SWIG_Py_Void();
11125 return resultobj;
11126 fail:
11127 return NULL;
11128 }
11129
11130
11131 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132 PyObject *resultobj = 0;
11133
11134 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11135 {
11136 PyThreadState* __tstate = wxPyBeginAllowThreads();
11137 wxLog::FlushActive();
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 resultobj = SWIG_Py_Void();
11142 return resultobj;
11143 fail:
11144 return NULL;
11145 }
11146
11147
11148 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11149 PyObject *resultobj = 0;
11150 wxLog *result = 0 ;
11151
11152 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11153 {
11154 PyThreadState* __tstate = wxPyBeginAllowThreads();
11155 result = (wxLog *)wxLog::GetActiveTarget();
11156 wxPyEndAllowThreads(__tstate);
11157 if (PyErr_Occurred()) SWIG_fail;
11158 }
11159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11160 return resultobj;
11161 fail:
11162 return NULL;
11163 }
11164
11165
11166 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11167 PyObject *resultobj = 0;
11168 wxLog *arg1 = (wxLog *) 0 ;
11169 wxLog *result = 0 ;
11170 int res1 = 0 ;
11171 PyObject * obj0 = 0 ;
11172 char * kwnames[] = {
11173 (char *) "pLogger", NULL
11174 };
11175
11176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11177 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11178 if (!SWIG_IsOK(res1)) {
11179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11180 }
11181 {
11182 PyThreadState* __tstate = wxPyBeginAllowThreads();
11183 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11184 wxPyEndAllowThreads(__tstate);
11185 if (PyErr_Occurred()) SWIG_fail;
11186 }
11187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11188 return resultobj;
11189 fail:
11190 return NULL;
11191 }
11192
11193
11194 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11195 PyObject *resultobj = 0;
11196
11197 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11198 {
11199 PyThreadState* __tstate = wxPyBeginAllowThreads();
11200 wxLog::Suspend();
11201 wxPyEndAllowThreads(__tstate);
11202 if (PyErr_Occurred()) SWIG_fail;
11203 }
11204 resultobj = SWIG_Py_Void();
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11212 PyObject *resultobj = 0;
11213
11214 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11215 {
11216 PyThreadState* __tstate = wxPyBeginAllowThreads();
11217 wxLog::Resume();
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 resultobj = SWIG_Py_Void();
11222 return resultobj;
11223 fail:
11224 return NULL;
11225 }
11226
11227
11228 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11229 PyObject *resultobj = 0;
11230 bool arg1 = (bool) true ;
11231 bool val1 ;
11232 int ecode1 = 0 ;
11233 PyObject * obj0 = 0 ;
11234 char * kwnames[] = {
11235 (char *) "bVerbose", NULL
11236 };
11237
11238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11239 if (obj0) {
11240 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11241 if (!SWIG_IsOK(ecode1)) {
11242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11243 }
11244 arg1 = static_cast< bool >(val1);
11245 }
11246 {
11247 PyThreadState* __tstate = wxPyBeginAllowThreads();
11248 wxLog::SetVerbose(arg1);
11249 wxPyEndAllowThreads(__tstate);
11250 if (PyErr_Occurred()) SWIG_fail;
11251 }
11252 resultobj = SWIG_Py_Void();
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj = 0;
11261 wxLogLevel arg1 ;
11262 unsigned long val1 ;
11263 int ecode1 = 0 ;
11264 PyObject * obj0 = 0 ;
11265 char * kwnames[] = {
11266 (char *) "logLevel", NULL
11267 };
11268
11269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11270 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11271 if (!SWIG_IsOK(ecode1)) {
11272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11273 }
11274 arg1 = static_cast< wxLogLevel >(val1);
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 wxLog::SetLogLevel(arg1);
11278 wxPyEndAllowThreads(__tstate);
11279 if (PyErr_Occurred()) SWIG_fail;
11280 }
11281 resultobj = SWIG_Py_Void();
11282 return resultobj;
11283 fail:
11284 return NULL;
11285 }
11286
11287
11288 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11289 PyObject *resultobj = 0;
11290
11291 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11292 {
11293 PyThreadState* __tstate = wxPyBeginAllowThreads();
11294 wxLog::DontCreateOnDemand();
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 resultobj = SWIG_Py_Void();
11299 return resultobj;
11300 fail:
11301 return NULL;
11302 }
11303
11304
11305 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11306 PyObject *resultobj = 0;
11307 wxTraceMask arg1 ;
11308 unsigned long val1 ;
11309 int ecode1 = 0 ;
11310 PyObject * obj0 = 0 ;
11311 char * kwnames[] = {
11312 (char *) "ulMask", NULL
11313 };
11314
11315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11316 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11317 if (!SWIG_IsOK(ecode1)) {
11318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11319 }
11320 arg1 = static_cast< wxTraceMask >(val1);
11321 {
11322 PyThreadState* __tstate = wxPyBeginAllowThreads();
11323 wxLog::SetTraceMask(arg1);
11324 wxPyEndAllowThreads(__tstate);
11325 if (PyErr_Occurred()) SWIG_fail;
11326 }
11327 resultobj = SWIG_Py_Void();
11328 return resultobj;
11329 fail:
11330 return NULL;
11331 }
11332
11333
11334 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11335 PyObject *resultobj = 0;
11336 wxString *arg1 = 0 ;
11337 bool temp1 = false ;
11338 PyObject * obj0 = 0 ;
11339 char * kwnames[] = {
11340 (char *) "str", NULL
11341 };
11342
11343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11344 {
11345 arg1 = wxString_in_helper(obj0);
11346 if (arg1 == NULL) SWIG_fail;
11347 temp1 = true;
11348 }
11349 {
11350 PyThreadState* __tstate = wxPyBeginAllowThreads();
11351 wxLog::AddTraceMask((wxString const &)*arg1);
11352 wxPyEndAllowThreads(__tstate);
11353 if (PyErr_Occurred()) SWIG_fail;
11354 }
11355 resultobj = SWIG_Py_Void();
11356 {
11357 if (temp1)
11358 delete arg1;
11359 }
11360 return resultobj;
11361 fail:
11362 {
11363 if (temp1)
11364 delete arg1;
11365 }
11366 return NULL;
11367 }
11368
11369
11370 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11371 PyObject *resultobj = 0;
11372 wxString *arg1 = 0 ;
11373 bool temp1 = false ;
11374 PyObject * obj0 = 0 ;
11375 char * kwnames[] = {
11376 (char *) "str", NULL
11377 };
11378
11379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11380 {
11381 arg1 = wxString_in_helper(obj0);
11382 if (arg1 == NULL) SWIG_fail;
11383 temp1 = true;
11384 }
11385 {
11386 PyThreadState* __tstate = wxPyBeginAllowThreads();
11387 wxLog::RemoveTraceMask((wxString const &)*arg1);
11388 wxPyEndAllowThreads(__tstate);
11389 if (PyErr_Occurred()) SWIG_fail;
11390 }
11391 resultobj = SWIG_Py_Void();
11392 {
11393 if (temp1)
11394 delete arg1;
11395 }
11396 return resultobj;
11397 fail:
11398 {
11399 if (temp1)
11400 delete arg1;
11401 }
11402 return NULL;
11403 }
11404
11405
11406 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11407 PyObject *resultobj = 0;
11408
11409 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 wxLog::ClearTraceMasks();
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 resultobj = SWIG_Py_Void();
11417 return resultobj;
11418 fail:
11419 return NULL;
11420 }
11421
11422
11423 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11424 PyObject *resultobj = 0;
11425 wxArrayString *result = 0 ;
11426
11427 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 {
11431 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11432 result = (wxArrayString *) &_result_ref;
11433 }
11434 wxPyEndAllowThreads(__tstate);
11435 if (PyErr_Occurred()) SWIG_fail;
11436 }
11437 {
11438 resultobj = wxArrayString2PyList_helper(*result);
11439 }
11440 return resultobj;
11441 fail:
11442 return NULL;
11443 }
11444
11445
11446 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11447 PyObject *resultobj = 0;
11448 wxChar *arg1 = (wxChar *) 0 ;
11449 void *argp1 = 0 ;
11450 int res1 = 0 ;
11451 PyObject * obj0 = 0 ;
11452 char * kwnames[] = {
11453 (char *) "ts", NULL
11454 };
11455
11456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11458 if (!SWIG_IsOK(res1)) {
11459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11460 }
11461 arg1 = reinterpret_cast< wxChar * >(argp1);
11462 {
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 wxLog::SetTimestamp((wxChar const *)arg1);
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 resultobj = SWIG_Py_Void();
11469 return resultobj;
11470 fail:
11471 return NULL;
11472 }
11473
11474
11475 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11476 PyObject *resultobj = 0;
11477 bool result;
11478
11479 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11480 {
11481 PyThreadState* __tstate = wxPyBeginAllowThreads();
11482 result = (bool)wxLog::GetVerbose();
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 {
11487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11488 }
11489 return resultobj;
11490 fail:
11491 return NULL;
11492 }
11493
11494
11495 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11496 PyObject *resultobj = 0;
11497 wxTraceMask result;
11498
11499 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11500 {
11501 PyThreadState* __tstate = wxPyBeginAllowThreads();
11502 result = (wxTraceMask)wxLog::GetTraceMask();
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11507 return resultobj;
11508 fail:
11509 return NULL;
11510 }
11511
11512
11513 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11514 PyObject *resultobj = 0;
11515 wxChar *arg1 = (wxChar *) 0 ;
11516 bool result;
11517 void *argp1 = 0 ;
11518 int res1 = 0 ;
11519 PyObject * obj0 = 0 ;
11520 char * kwnames[] = {
11521 (char *) "mask", NULL
11522 };
11523
11524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11526 if (!SWIG_IsOK(res1)) {
11527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11528 }
11529 arg1 = reinterpret_cast< wxChar * >(argp1);
11530 {
11531 PyThreadState* __tstate = wxPyBeginAllowThreads();
11532 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 {
11537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11538 }
11539 return resultobj;
11540 fail:
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11546 PyObject *resultobj = 0;
11547 wxLogLevel result;
11548
11549 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (wxLogLevel)wxLog::GetLogLevel();
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11564 PyObject *resultobj = 0;
11565 wxChar *result = 0 ;
11566
11567 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 result = (wxChar *)wxLog::GetTimestamp();
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11575 return resultobj;
11576 fail:
11577 return NULL;
11578 }
11579
11580
11581 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11582 PyObject *resultobj = 0;
11583 wxString result;
11584
11585 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11586 {
11587 PyThreadState* __tstate = wxPyBeginAllowThreads();
11588 result = wxLog_TimeStamp();
11589 wxPyEndAllowThreads(__tstate);
11590 if (PyErr_Occurred()) SWIG_fail;
11591 }
11592 {
11593 #if wxUSE_UNICODE
11594 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11595 #else
11596 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11597 #endif
11598 }
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11606 PyObject *resultobj = 0;
11607 wxLog *arg1 = (wxLog *) 0 ;
11608 void *argp1 = 0 ;
11609 int res1 = 0 ;
11610 PyObject *swig_obj[1] ;
11611
11612 if (!args) SWIG_fail;
11613 swig_obj[0] = args;
11614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11615 if (!SWIG_IsOK(res1)) {
11616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11617 }
11618 arg1 = reinterpret_cast< wxLog * >(argp1);
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 wxLog_Destroy(arg1);
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 resultobj = SWIG_Py_Void();
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11633 PyObject *obj;
11634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11635 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11636 return SWIG_Py_Void();
11637 }
11638
11639 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11640 return SWIG_Python_InitShadowInstance(args);
11641 }
11642
11643 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11644 PyObject *resultobj = 0;
11645 wxLogStderr *result = 0 ;
11646
11647 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 result = (wxLogStderr *)new wxLogStderr();
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11662 PyObject *obj;
11663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11664 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11665 return SWIG_Py_Void();
11666 }
11667
11668 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11669 return SWIG_Python_InitShadowInstance(args);
11670 }
11671
11672 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11673 PyObject *resultobj = 0;
11674 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11675 wxLogTextCtrl *result = 0 ;
11676 void *argp1 = 0 ;
11677 int res1 = 0 ;
11678 PyObject * obj0 = 0 ;
11679 char * kwnames[] = {
11680 (char *) "pTextCtrl", NULL
11681 };
11682
11683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11685 if (!SWIG_IsOK(res1)) {
11686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11687 }
11688 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11692 wxPyEndAllowThreads(__tstate);
11693 if (PyErr_Occurred()) SWIG_fail;
11694 }
11695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11696 return resultobj;
11697 fail:
11698 return NULL;
11699 }
11700
11701
11702 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11703 PyObject *obj;
11704 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11705 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11706 return SWIG_Py_Void();
11707 }
11708
11709 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11710 return SWIG_Python_InitShadowInstance(args);
11711 }
11712
11713 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11714 PyObject *resultobj = 0;
11715 wxLogGui *result = 0 ;
11716
11717 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11718 {
11719 PyThreadState* __tstate = wxPyBeginAllowThreads();
11720 result = (wxLogGui *)new wxLogGui();
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11725 return resultobj;
11726 fail:
11727 return NULL;
11728 }
11729
11730
11731 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11732 PyObject *obj;
11733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11734 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11735 return SWIG_Py_Void();
11736 }
11737
11738 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11739 return SWIG_Python_InitShadowInstance(args);
11740 }
11741
11742 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11743 PyObject *resultobj = 0;
11744 wxFrame *arg1 = (wxFrame *) 0 ;
11745 wxString *arg2 = 0 ;
11746 bool arg3 = (bool) true ;
11747 bool arg4 = (bool) true ;
11748 wxLogWindow *result = 0 ;
11749 void *argp1 = 0 ;
11750 int res1 = 0 ;
11751 bool temp2 = false ;
11752 bool val3 ;
11753 int ecode3 = 0 ;
11754 bool val4 ;
11755 int ecode4 = 0 ;
11756 PyObject * obj0 = 0 ;
11757 PyObject * obj1 = 0 ;
11758 PyObject * obj2 = 0 ;
11759 PyObject * obj3 = 0 ;
11760 char * kwnames[] = {
11761 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11762 };
11763
11764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11768 }
11769 arg1 = reinterpret_cast< wxFrame * >(argp1);
11770 {
11771 arg2 = wxString_in_helper(obj1);
11772 if (arg2 == NULL) SWIG_fail;
11773 temp2 = true;
11774 }
11775 if (obj2) {
11776 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11777 if (!SWIG_IsOK(ecode3)) {
11778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11779 }
11780 arg3 = static_cast< bool >(val3);
11781 }
11782 if (obj3) {
11783 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11784 if (!SWIG_IsOK(ecode4)) {
11785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11786 }
11787 arg4 = static_cast< bool >(val4);
11788 }
11789 {
11790 PyThreadState* __tstate = wxPyBeginAllowThreads();
11791 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11792 wxPyEndAllowThreads(__tstate);
11793 if (PyErr_Occurred()) SWIG_fail;
11794 }
11795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11796 {
11797 if (temp2)
11798 delete arg2;
11799 }
11800 return resultobj;
11801 fail:
11802 {
11803 if (temp2)
11804 delete arg2;
11805 }
11806 return NULL;
11807 }
11808
11809
11810 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj = 0;
11812 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11813 bool arg2 = (bool) true ;
11814 void *argp1 = 0 ;
11815 int res1 = 0 ;
11816 bool val2 ;
11817 int ecode2 = 0 ;
11818 PyObject * obj0 = 0 ;
11819 PyObject * obj1 = 0 ;
11820 char * kwnames[] = {
11821 (char *) "self",(char *) "bShow", NULL
11822 };
11823
11824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11826 if (!SWIG_IsOK(res1)) {
11827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11828 }
11829 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11830 if (obj1) {
11831 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11832 if (!SWIG_IsOK(ecode2)) {
11833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11834 }
11835 arg2 = static_cast< bool >(val2);
11836 }
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 (arg1)->Show(arg2);
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 resultobj = SWIG_Py_Void();
11844 return resultobj;
11845 fail:
11846 return NULL;
11847 }
11848
11849
11850 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11851 PyObject *resultobj = 0;
11852 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11853 wxFrame *result = 0 ;
11854 void *argp1 = 0 ;
11855 int res1 = 0 ;
11856 PyObject *swig_obj[1] ;
11857
11858 if (!args) SWIG_fail;
11859 swig_obj[0] = args;
11860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11861 if (!SWIG_IsOK(res1)) {
11862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11863 }
11864 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11868 wxPyEndAllowThreads(__tstate);
11869 if (PyErr_Occurred()) SWIG_fail;
11870 }
11871 {
11872 resultobj = wxPyMake_wxObject(result, (bool)0);
11873 }
11874 return resultobj;
11875 fail:
11876 return NULL;
11877 }
11878
11879
11880 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11881 PyObject *resultobj = 0;
11882 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11883 wxLog *result = 0 ;
11884 void *argp1 = 0 ;
11885 int res1 = 0 ;
11886 PyObject *swig_obj[1] ;
11887
11888 if (!args) SWIG_fail;
11889 swig_obj[0] = args;
11890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11891 if (!SWIG_IsOK(res1)) {
11892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11893 }
11894 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11898 wxPyEndAllowThreads(__tstate);
11899 if (PyErr_Occurred()) SWIG_fail;
11900 }
11901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11902 return resultobj;
11903 fail:
11904 return NULL;
11905 }
11906
11907
11908 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11909 PyObject *resultobj = 0;
11910 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11911 bool result;
11912 void *argp1 = 0 ;
11913 int res1 = 0 ;
11914 PyObject *swig_obj[1] ;
11915
11916 if (!args) SWIG_fail;
11917 swig_obj[0] = args;
11918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11919 if (!SWIG_IsOK(res1)) {
11920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11921 }
11922 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11926 wxPyEndAllowThreads(__tstate);
11927 if (PyErr_Occurred()) SWIG_fail;
11928 }
11929 {
11930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11931 }
11932 return resultobj;
11933 fail:
11934 return NULL;
11935 }
11936
11937
11938 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11939 PyObject *resultobj = 0;
11940 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11941 bool arg2 ;
11942 void *argp1 = 0 ;
11943 int res1 = 0 ;
11944 bool val2 ;
11945 int ecode2 = 0 ;
11946 PyObject * obj0 = 0 ;
11947 PyObject * obj1 = 0 ;
11948 char * kwnames[] = {
11949 (char *) "self",(char *) "bDoPass", NULL
11950 };
11951
11952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11954 if (!SWIG_IsOK(res1)) {
11955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11956 }
11957 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11958 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11959 if (!SWIG_IsOK(ecode2)) {
11960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11961 }
11962 arg2 = static_cast< bool >(val2);
11963 {
11964 PyThreadState* __tstate = wxPyBeginAllowThreads();
11965 (arg1)->PassMessages(arg2);
11966 wxPyEndAllowThreads(__tstate);
11967 if (PyErr_Occurred()) SWIG_fail;
11968 }
11969 resultobj = SWIG_Py_Void();
11970 return resultobj;
11971 fail:
11972 return NULL;
11973 }
11974
11975
11976 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11977 PyObject *obj;
11978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11979 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11980 return SWIG_Py_Void();
11981 }
11982
11983 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11984 return SWIG_Python_InitShadowInstance(args);
11985 }
11986
11987 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj = 0;
11989 wxLog *arg1 = (wxLog *) 0 ;
11990 wxLogChain *result = 0 ;
11991 void *argp1 = 0 ;
11992 int res1 = 0 ;
11993 PyObject * obj0 = 0 ;
11994 char * kwnames[] = {
11995 (char *) "logger", NULL
11996 };
11997
11998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
11999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12000 if (!SWIG_IsOK(res1)) {
12001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12002 }
12003 arg1 = reinterpret_cast< wxLog * >(argp1);
12004 {
12005 PyThreadState* __tstate = wxPyBeginAllowThreads();
12006 result = (wxLogChain *)new wxLogChain(arg1);
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12011 return resultobj;
12012 fail:
12013 return NULL;
12014 }
12015
12016
12017 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj = 0;
12019 wxLogChain *arg1 = (wxLogChain *) 0 ;
12020 wxLog *arg2 = (wxLog *) 0 ;
12021 void *argp1 = 0 ;
12022 int res1 = 0 ;
12023 void *argp2 = 0 ;
12024 int res2 = 0 ;
12025 PyObject * obj0 = 0 ;
12026 PyObject * obj1 = 0 ;
12027 char * kwnames[] = {
12028 (char *) "self",(char *) "logger", NULL
12029 };
12030
12031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12033 if (!SWIG_IsOK(res1)) {
12034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12035 }
12036 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12037 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12038 if (!SWIG_IsOK(res2)) {
12039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12040 }
12041 arg2 = reinterpret_cast< wxLog * >(argp2);
12042 {
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 (arg1)->SetLog(arg2);
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 resultobj = SWIG_Py_Void();
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12056 PyObject *resultobj = 0;
12057 wxLogChain *arg1 = (wxLogChain *) 0 ;
12058 bool arg2 ;
12059 void *argp1 = 0 ;
12060 int res1 = 0 ;
12061 bool val2 ;
12062 int ecode2 = 0 ;
12063 PyObject * obj0 = 0 ;
12064 PyObject * obj1 = 0 ;
12065 char * kwnames[] = {
12066 (char *) "self",(char *) "bDoPass", NULL
12067 };
12068
12069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12071 if (!SWIG_IsOK(res1)) {
12072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12073 }
12074 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12075 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12076 if (!SWIG_IsOK(ecode2)) {
12077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12078 }
12079 arg2 = static_cast< bool >(val2);
12080 {
12081 PyThreadState* __tstate = wxPyBeginAllowThreads();
12082 (arg1)->PassMessages(arg2);
12083 wxPyEndAllowThreads(__tstate);
12084 if (PyErr_Occurred()) SWIG_fail;
12085 }
12086 resultobj = SWIG_Py_Void();
12087 return resultobj;
12088 fail:
12089 return NULL;
12090 }
12091
12092
12093 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12094 PyObject *resultobj = 0;
12095 wxLogChain *arg1 = (wxLogChain *) 0 ;
12096 bool result;
12097 void *argp1 = 0 ;
12098 int res1 = 0 ;
12099 PyObject *swig_obj[1] ;
12100
12101 if (!args) SWIG_fail;
12102 swig_obj[0] = args;
12103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12104 if (!SWIG_IsOK(res1)) {
12105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12106 }
12107 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 result = (bool)(arg1)->IsPassingMessages();
12111 wxPyEndAllowThreads(__tstate);
12112 if (PyErr_Occurred()) SWIG_fail;
12113 }
12114 {
12115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12116 }
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12124 PyObject *resultobj = 0;
12125 wxLogChain *arg1 = (wxLogChain *) 0 ;
12126 wxLog *result = 0 ;
12127 void *argp1 = 0 ;
12128 int res1 = 0 ;
12129 PyObject *swig_obj[1] ;
12130
12131 if (!args) SWIG_fail;
12132 swig_obj[0] = args;
12133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12134 if (!SWIG_IsOK(res1)) {
12135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12136 }
12137 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 result = (wxLog *)(arg1)->GetOldLog();
12141 wxPyEndAllowThreads(__tstate);
12142 if (PyErr_Occurred()) SWIG_fail;
12143 }
12144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12145 return resultobj;
12146 fail:
12147 return NULL;
12148 }
12149
12150
12151 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152 PyObject *obj;
12153 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12154 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12155 return SWIG_Py_Void();
12156 }
12157
12158 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12159 return SWIG_Python_InitShadowInstance(args);
12160 }
12161
12162 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12163 PyObject *resultobj = 0;
12164 wxLogBuffer *result = 0 ;
12165
12166 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (wxLogBuffer *)new wxLogBuffer();
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12181 PyObject *resultobj = 0;
12182 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12183 wxString *result = 0 ;
12184 void *argp1 = 0 ;
12185 int res1 = 0 ;
12186 PyObject *swig_obj[1] ;
12187
12188 if (!args) SWIG_fail;
12189 swig_obj[0] = args;
12190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12191 if (!SWIG_IsOK(res1)) {
12192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12193 }
12194 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 {
12198 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12199 result = (wxString *) &_result_ref;
12200 }
12201 wxPyEndAllowThreads(__tstate);
12202 if (PyErr_Occurred()) SWIG_fail;
12203 }
12204 {
12205 #if wxUSE_UNICODE
12206 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12207 #else
12208 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12209 #endif
12210 }
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12218 PyObject *obj;
12219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12220 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12221 return SWIG_Py_Void();
12222 }
12223
12224 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12225 return SWIG_Python_InitShadowInstance(args);
12226 }
12227
12228 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12229 PyObject *resultobj = 0;
12230 unsigned long result;
12231
12232 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12233 {
12234 PyThreadState* __tstate = wxPyBeginAllowThreads();
12235 result = (unsigned long)wxSysErrorCode();
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj = 0;
12248 unsigned long arg1 = (unsigned long) 0 ;
12249 wxString result;
12250 unsigned long val1 ;
12251 int ecode1 = 0 ;
12252 PyObject * obj0 = 0 ;
12253 char * kwnames[] = {
12254 (char *) "nErrCode", NULL
12255 };
12256
12257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12258 if (obj0) {
12259 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12260 if (!SWIG_IsOK(ecode1)) {
12261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12262 }
12263 arg1 = static_cast< unsigned long >(val1);
12264 }
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 result = wxSysErrorMsg(arg1);
12268 wxPyEndAllowThreads(__tstate);
12269 if (PyErr_Occurred()) SWIG_fail;
12270 }
12271 {
12272 #if wxUSE_UNICODE
12273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12274 #else
12275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12276 #endif
12277 }
12278 return resultobj;
12279 fail:
12280 return NULL;
12281 }
12282
12283
12284 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12285 PyObject *resultobj = 0;
12286 wxString *arg1 = 0 ;
12287 bool temp1 = false ;
12288 PyObject * obj0 = 0 ;
12289 char * kwnames[] = {
12290 (char *) "msg", NULL
12291 };
12292
12293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12294 {
12295 arg1 = wxString_in_helper(obj0);
12296 if (arg1 == NULL) SWIG_fail;
12297 temp1 = true;
12298 }
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 wxPyLogFatalError((wxString const &)*arg1);
12302 wxPyEndAllowThreads(__tstate);
12303 if (PyErr_Occurred()) SWIG_fail;
12304 }
12305 resultobj = SWIG_Py_Void();
12306 {
12307 if (temp1)
12308 delete arg1;
12309 }
12310 return resultobj;
12311 fail:
12312 {
12313 if (temp1)
12314 delete arg1;
12315 }
12316 return NULL;
12317 }
12318
12319
12320 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12321 PyObject *resultobj = 0;
12322 wxString *arg1 = 0 ;
12323 bool temp1 = false ;
12324 PyObject * obj0 = 0 ;
12325 char * kwnames[] = {
12326 (char *) "msg", NULL
12327 };
12328
12329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12330 {
12331 arg1 = wxString_in_helper(obj0);
12332 if (arg1 == NULL) SWIG_fail;
12333 temp1 = true;
12334 }
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 wxPyLogError((wxString const &)*arg1);
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 resultobj = SWIG_Py_Void();
12342 {
12343 if (temp1)
12344 delete arg1;
12345 }
12346 return resultobj;
12347 fail:
12348 {
12349 if (temp1)
12350 delete arg1;
12351 }
12352 return NULL;
12353 }
12354
12355
12356 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12357 PyObject *resultobj = 0;
12358 wxString *arg1 = 0 ;
12359 bool temp1 = false ;
12360 PyObject * obj0 = 0 ;
12361 char * kwnames[] = {
12362 (char *) "msg", NULL
12363 };
12364
12365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12366 {
12367 arg1 = wxString_in_helper(obj0);
12368 if (arg1 == NULL) SWIG_fail;
12369 temp1 = true;
12370 }
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 wxPyLogWarning((wxString const &)*arg1);
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 resultobj = SWIG_Py_Void();
12378 {
12379 if (temp1)
12380 delete arg1;
12381 }
12382 return resultobj;
12383 fail:
12384 {
12385 if (temp1)
12386 delete arg1;
12387 }
12388 return NULL;
12389 }
12390
12391
12392 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12393 PyObject *resultobj = 0;
12394 wxString *arg1 = 0 ;
12395 bool temp1 = false ;
12396 PyObject * obj0 = 0 ;
12397 char * kwnames[] = {
12398 (char *) "msg", NULL
12399 };
12400
12401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12402 {
12403 arg1 = wxString_in_helper(obj0);
12404 if (arg1 == NULL) SWIG_fail;
12405 temp1 = true;
12406 }
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 wxPyLogMessage((wxString const &)*arg1);
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 resultobj = SWIG_Py_Void();
12414 {
12415 if (temp1)
12416 delete arg1;
12417 }
12418 return resultobj;
12419 fail:
12420 {
12421 if (temp1)
12422 delete arg1;
12423 }
12424 return NULL;
12425 }
12426
12427
12428 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12429 PyObject *resultobj = 0;
12430 wxString *arg1 = 0 ;
12431 bool temp1 = false ;
12432 PyObject * obj0 = 0 ;
12433 char * kwnames[] = {
12434 (char *) "msg", NULL
12435 };
12436
12437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12438 {
12439 arg1 = wxString_in_helper(obj0);
12440 if (arg1 == NULL) SWIG_fail;
12441 temp1 = true;
12442 }
12443 {
12444 PyThreadState* __tstate = wxPyBeginAllowThreads();
12445 wxPyLogInfo((wxString const &)*arg1);
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 resultobj = SWIG_Py_Void();
12450 {
12451 if (temp1)
12452 delete arg1;
12453 }
12454 return resultobj;
12455 fail:
12456 {
12457 if (temp1)
12458 delete arg1;
12459 }
12460 return NULL;
12461 }
12462
12463
12464 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12465 PyObject *resultobj = 0;
12466 wxString *arg1 = 0 ;
12467 bool temp1 = false ;
12468 PyObject * obj0 = 0 ;
12469 char * kwnames[] = {
12470 (char *) "msg", NULL
12471 };
12472
12473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12474 {
12475 arg1 = wxString_in_helper(obj0);
12476 if (arg1 == NULL) SWIG_fail;
12477 temp1 = true;
12478 }
12479 {
12480 PyThreadState* __tstate = wxPyBeginAllowThreads();
12481 wxPyLogDebug((wxString const &)*arg1);
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 resultobj = SWIG_Py_Void();
12486 {
12487 if (temp1)
12488 delete arg1;
12489 }
12490 return resultobj;
12491 fail:
12492 {
12493 if (temp1)
12494 delete arg1;
12495 }
12496 return NULL;
12497 }
12498
12499
12500 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12501 PyObject *resultobj = 0;
12502 wxString *arg1 = 0 ;
12503 bool temp1 = false ;
12504 PyObject * obj0 = 0 ;
12505 char * kwnames[] = {
12506 (char *) "msg", NULL
12507 };
12508
12509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12510 {
12511 arg1 = wxString_in_helper(obj0);
12512 if (arg1 == NULL) SWIG_fail;
12513 temp1 = true;
12514 }
12515 {
12516 PyThreadState* __tstate = wxPyBeginAllowThreads();
12517 wxPyLogVerbose((wxString const &)*arg1);
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 resultobj = SWIG_Py_Void();
12522 {
12523 if (temp1)
12524 delete arg1;
12525 }
12526 return resultobj;
12527 fail:
12528 {
12529 if (temp1)
12530 delete arg1;
12531 }
12532 return NULL;
12533 }
12534
12535
12536 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj = 0;
12538 wxString *arg1 = 0 ;
12539 bool temp1 = false ;
12540 PyObject * obj0 = 0 ;
12541 char * kwnames[] = {
12542 (char *) "msg", NULL
12543 };
12544
12545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12546 {
12547 arg1 = wxString_in_helper(obj0);
12548 if (arg1 == NULL) SWIG_fail;
12549 temp1 = true;
12550 }
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 wxPyLogStatus((wxString const &)*arg1);
12554 wxPyEndAllowThreads(__tstate);
12555 if (PyErr_Occurred()) SWIG_fail;
12556 }
12557 resultobj = SWIG_Py_Void();
12558 {
12559 if (temp1)
12560 delete arg1;
12561 }
12562 return resultobj;
12563 fail:
12564 {
12565 if (temp1)
12566 delete arg1;
12567 }
12568 return NULL;
12569 }
12570
12571
12572 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj = 0;
12574 wxFrame *arg1 = (wxFrame *) 0 ;
12575 wxString *arg2 = 0 ;
12576 void *argp1 = 0 ;
12577 int res1 = 0 ;
12578 bool temp2 = false ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 char * kwnames[] = {
12582 (char *) "pFrame",(char *) "msg", NULL
12583 };
12584
12585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12587 if (!SWIG_IsOK(res1)) {
12588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12589 }
12590 arg1 = reinterpret_cast< wxFrame * >(argp1);
12591 {
12592 arg2 = wxString_in_helper(obj1);
12593 if (arg2 == NULL) SWIG_fail;
12594 temp2 = true;
12595 }
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12599 wxPyEndAllowThreads(__tstate);
12600 if (PyErr_Occurred()) SWIG_fail;
12601 }
12602 resultobj = SWIG_Py_Void();
12603 {
12604 if (temp2)
12605 delete arg2;
12606 }
12607 return resultobj;
12608 fail:
12609 {
12610 if (temp2)
12611 delete arg2;
12612 }
12613 return NULL;
12614 }
12615
12616
12617 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12618 PyObject *resultobj = 0;
12619 wxString *arg1 = 0 ;
12620 bool temp1 = false ;
12621 PyObject * obj0 = 0 ;
12622 char * kwnames[] = {
12623 (char *) "msg", NULL
12624 };
12625
12626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12627 {
12628 arg1 = wxString_in_helper(obj0);
12629 if (arg1 == NULL) SWIG_fail;
12630 temp1 = true;
12631 }
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 wxPyLogSysError((wxString const &)*arg1);
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 resultobj = SWIG_Py_Void();
12639 {
12640 if (temp1)
12641 delete arg1;
12642 }
12643 return resultobj;
12644 fail:
12645 {
12646 if (temp1)
12647 delete arg1;
12648 }
12649 return NULL;
12650 }
12651
12652
12653 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12654 PyObject *resultobj = 0;
12655 unsigned long arg1 ;
12656 wxString *arg2 = 0 ;
12657 unsigned long val1 ;
12658 int ecode1 = 0 ;
12659 bool temp2 = false ;
12660 PyObject * obj0 = 0 ;
12661 PyObject * obj1 = 0 ;
12662 char * kwnames[] = {
12663 (char *) "level",(char *) "msg", NULL
12664 };
12665
12666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12667 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12668 if (!SWIG_IsOK(ecode1)) {
12669 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12670 }
12671 arg1 = static_cast< unsigned long >(val1);
12672 {
12673 arg2 = wxString_in_helper(obj1);
12674 if (arg2 == NULL) SWIG_fail;
12675 temp2 = true;
12676 }
12677 {
12678 PyThreadState* __tstate = wxPyBeginAllowThreads();
12679 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12680 wxPyEndAllowThreads(__tstate);
12681 if (PyErr_Occurred()) SWIG_fail;
12682 }
12683 resultobj = SWIG_Py_Void();
12684 {
12685 if (temp2)
12686 delete arg2;
12687 }
12688 return resultobj;
12689 fail:
12690 {
12691 if (temp2)
12692 delete arg2;
12693 }
12694 return NULL;
12695 }
12696
12697
12698 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12699 PyObject *resultobj = 0;
12700 unsigned long arg1 ;
12701 wxString *arg2 = 0 ;
12702 unsigned long val1 ;
12703 int ecode1 = 0 ;
12704 bool temp2 = false ;
12705
12706 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12707 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12708 if (!SWIG_IsOK(ecode1)) {
12709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12710 }
12711 arg1 = static_cast< unsigned long >(val1);
12712 {
12713 arg2 = wxString_in_helper(swig_obj[1]);
12714 if (arg2 == NULL) SWIG_fail;
12715 temp2 = true;
12716 }
12717 {
12718 PyThreadState* __tstate = wxPyBeginAllowThreads();
12719 wxPyLogTrace(arg1,(wxString const &)*arg2);
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 resultobj = SWIG_Py_Void();
12724 {
12725 if (temp2)
12726 delete arg2;
12727 }
12728 return resultobj;
12729 fail:
12730 {
12731 if (temp2)
12732 delete arg2;
12733 }
12734 return NULL;
12735 }
12736
12737
12738 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12739 PyObject *resultobj = 0;
12740 wxString *arg1 = 0 ;
12741 wxString *arg2 = 0 ;
12742 bool temp1 = false ;
12743 bool temp2 = false ;
12744
12745 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12746 {
12747 arg1 = wxString_in_helper(swig_obj[0]);
12748 if (arg1 == NULL) SWIG_fail;
12749 temp1 = true;
12750 }
12751 {
12752 arg2 = wxString_in_helper(swig_obj[1]);
12753 if (arg2 == NULL) SWIG_fail;
12754 temp2 = true;
12755 }
12756 {
12757 PyThreadState* __tstate = wxPyBeginAllowThreads();
12758 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 resultobj = SWIG_Py_Void();
12763 {
12764 if (temp1)
12765 delete arg1;
12766 }
12767 {
12768 if (temp2)
12769 delete arg2;
12770 }
12771 return resultobj;
12772 fail:
12773 {
12774 if (temp1)
12775 delete arg1;
12776 }
12777 {
12778 if (temp2)
12779 delete arg2;
12780 }
12781 return NULL;
12782 }
12783
12784
12785 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12786 int argc;
12787 PyObject *argv[3];
12788
12789 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12790 --argc;
12791 if (argc == 2) {
12792 int _v = 0;
12793 {
12794 {
12795 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12796 }
12797 }
12798 if (!_v) goto check_1;
12799 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12800 }
12801 check_1:
12802
12803 if (argc == 2) {
12804 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12805 }
12806
12807 fail:
12808 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12809 return NULL;
12810 }
12811
12812
12813 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj = 0;
12815 wxString *arg1 = 0 ;
12816 wxString *arg2 = 0 ;
12817 bool temp1 = false ;
12818 bool temp2 = false ;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 char * kwnames[] = {
12822 (char *) "title",(char *) "text", NULL
12823 };
12824
12825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12826 {
12827 arg1 = wxString_in_helper(obj0);
12828 if (arg1 == NULL) SWIG_fail;
12829 temp1 = true;
12830 }
12831 {
12832 arg2 = wxString_in_helper(obj1);
12833 if (arg2 == NULL) SWIG_fail;
12834 temp2 = true;
12835 }
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12839 wxPyEndAllowThreads(__tstate);
12840 if (PyErr_Occurred()) SWIG_fail;
12841 }
12842 resultobj = SWIG_Py_Void();
12843 {
12844 if (temp1)
12845 delete arg1;
12846 }
12847 {
12848 if (temp2)
12849 delete arg2;
12850 }
12851 return resultobj;
12852 fail:
12853 {
12854 if (temp1)
12855 delete arg1;
12856 }
12857 {
12858 if (temp2)
12859 delete arg2;
12860 }
12861 return NULL;
12862 }
12863
12864
12865 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12866 PyObject *resultobj = 0;
12867 wxLogNull *result = 0 ;
12868
12869 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 result = (wxLogNull *)new wxLogNull();
12873 wxPyEndAllowThreads(__tstate);
12874 if (PyErr_Occurred()) SWIG_fail;
12875 }
12876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12877 return resultobj;
12878 fail:
12879 return NULL;
12880 }
12881
12882
12883 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12884 PyObject *resultobj = 0;
12885 wxLogNull *arg1 = (wxLogNull *) 0 ;
12886 void *argp1 = 0 ;
12887 int res1 = 0 ;
12888 PyObject *swig_obj[1] ;
12889
12890 if (!args) SWIG_fail;
12891 swig_obj[0] = args;
12892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12893 if (!SWIG_IsOK(res1)) {
12894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12895 }
12896 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12897 {
12898 PyThreadState* __tstate = wxPyBeginAllowThreads();
12899 delete arg1;
12900
12901 wxPyEndAllowThreads(__tstate);
12902 if (PyErr_Occurred()) SWIG_fail;
12903 }
12904 resultobj = SWIG_Py_Void();
12905 return resultobj;
12906 fail:
12907 return NULL;
12908 }
12909
12910
12911 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912 PyObject *obj;
12913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12914 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12915 return SWIG_Py_Void();
12916 }
12917
12918 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919 return SWIG_Python_InitShadowInstance(args);
12920 }
12921
12922 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12923 PyObject *resultobj = 0;
12924 wxPyLog *result = 0 ;
12925
12926 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12927 {
12928 PyThreadState* __tstate = wxPyBeginAllowThreads();
12929 result = (wxPyLog *)new wxPyLog();
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12941 PyObject *resultobj = 0;
12942 wxPyLog *arg1 = (wxPyLog *) 0 ;
12943 PyObject *arg2 = (PyObject *) 0 ;
12944 PyObject *arg3 = (PyObject *) 0 ;
12945 void *argp1 = 0 ;
12946 int res1 = 0 ;
12947 PyObject * obj0 = 0 ;
12948 PyObject * obj1 = 0 ;
12949 PyObject * obj2 = 0 ;
12950 char * kwnames[] = {
12951 (char *) "self",(char *) "self",(char *) "_class", NULL
12952 };
12953
12954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12956 if (!SWIG_IsOK(res1)) {
12957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12958 }
12959 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12960 arg2 = obj1;
12961 arg3 = obj2;
12962 {
12963 PyThreadState* __tstate = wxPyBeginAllowThreads();
12964 (arg1)->_setCallbackInfo(arg2,arg3);
12965 wxPyEndAllowThreads(__tstate);
12966 if (PyErr_Occurred()) SWIG_fail;
12967 }
12968 resultobj = SWIG_Py_Void();
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 PyObject *obj;
12977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12978 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12979 return SWIG_Py_Void();
12980 }
12981
12982 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12983 return SWIG_Python_InitShadowInstance(args);
12984 }
12985
12986 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12987 PyObject *resultobj = 0;
12988 int arg1 ;
12989 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12990 int arg3 = (int) wxKILL_NOCHILDREN ;
12991 wxKillError result;
12992 int val1 ;
12993 int ecode1 = 0 ;
12994 int val2 ;
12995 int ecode2 = 0 ;
12996 int val3 ;
12997 int ecode3 = 0 ;
12998 PyObject * obj0 = 0 ;
12999 PyObject * obj1 = 0 ;
13000 PyObject * obj2 = 0 ;
13001 char * kwnames[] = {
13002 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13003 };
13004
13005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13006 ecode1 = SWIG_AsVal_int(obj0, &val1);
13007 if (!SWIG_IsOK(ecode1)) {
13008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13009 }
13010 arg1 = static_cast< int >(val1);
13011 if (obj1) {
13012 ecode2 = SWIG_AsVal_int(obj1, &val2);
13013 if (!SWIG_IsOK(ecode2)) {
13014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13015 }
13016 arg2 = static_cast< wxSignal >(val2);
13017 }
13018 if (obj2) {
13019 ecode3 = SWIG_AsVal_int(obj2, &val3);
13020 if (!SWIG_IsOK(ecode3)) {
13021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13022 }
13023 arg3 = static_cast< int >(val3);
13024 }
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 resultobj = SWIG_From_int(static_cast< int >(result));
13032 return resultobj;
13033 fail:
13034 return NULL;
13035 }
13036
13037
13038 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13039 PyObject *resultobj = 0;
13040 int arg1 ;
13041 bool result;
13042 int val1 ;
13043 int ecode1 = 0 ;
13044 PyObject * obj0 = 0 ;
13045 char * kwnames[] = {
13046 (char *) "pid", NULL
13047 };
13048
13049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13050 ecode1 = SWIG_AsVal_int(obj0, &val1);
13051 if (!SWIG_IsOK(ecode1)) {
13052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13053 }
13054 arg1 = static_cast< int >(val1);
13055 {
13056 PyThreadState* __tstate = wxPyBeginAllowThreads();
13057 result = (bool)wxPyProcess::Exists(arg1);
13058 wxPyEndAllowThreads(__tstate);
13059 if (PyErr_Occurred()) SWIG_fail;
13060 }
13061 {
13062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13063 }
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13071 PyObject *resultobj = 0;
13072 wxString *arg1 = 0 ;
13073 int arg2 = (int) wxEXEC_ASYNC ;
13074 wxPyProcess *result = 0 ;
13075 bool temp1 = false ;
13076 int val2 ;
13077 int ecode2 = 0 ;
13078 PyObject * obj0 = 0 ;
13079 PyObject * obj1 = 0 ;
13080 char * kwnames[] = {
13081 (char *) "cmd",(char *) "flags", NULL
13082 };
13083
13084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13085 {
13086 arg1 = wxString_in_helper(obj0);
13087 if (arg1 == NULL) SWIG_fail;
13088 temp1 = true;
13089 }
13090 if (obj1) {
13091 ecode2 = SWIG_AsVal_int(obj1, &val2);
13092 if (!SWIG_IsOK(ecode2)) {
13093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13094 }
13095 arg2 = static_cast< int >(val2);
13096 }
13097 {
13098 PyThreadState* __tstate = wxPyBeginAllowThreads();
13099 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13100 wxPyEndAllowThreads(__tstate);
13101 if (PyErr_Occurred()) SWIG_fail;
13102 }
13103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13104 {
13105 if (temp1)
13106 delete arg1;
13107 }
13108 return resultobj;
13109 fail:
13110 {
13111 if (temp1)
13112 delete arg1;
13113 }
13114 return NULL;
13115 }
13116
13117
13118 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13119 PyObject *resultobj = 0;
13120 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13121 int arg2 = (int) -1 ;
13122 wxPyProcess *result = 0 ;
13123 void *argp1 = 0 ;
13124 int res1 = 0 ;
13125 int val2 ;
13126 int ecode2 = 0 ;
13127 PyObject * obj0 = 0 ;
13128 PyObject * obj1 = 0 ;
13129 char * kwnames[] = {
13130 (char *) "parent",(char *) "id", NULL
13131 };
13132
13133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13134 if (obj0) {
13135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13136 if (!SWIG_IsOK(res1)) {
13137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13138 }
13139 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13140 }
13141 if (obj1) {
13142 ecode2 = SWIG_AsVal_int(obj1, &val2);
13143 if (!SWIG_IsOK(ecode2)) {
13144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13145 }
13146 arg2 = static_cast< int >(val2);
13147 }
13148 {
13149 PyThreadState* __tstate = wxPyBeginAllowThreads();
13150 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13151 wxPyEndAllowThreads(__tstate);
13152 if (PyErr_Occurred()) SWIG_fail;
13153 }
13154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13155 return resultobj;
13156 fail:
13157 return NULL;
13158 }
13159
13160
13161 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13162 PyObject *resultobj = 0;
13163 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13164 PyObject *arg2 = (PyObject *) 0 ;
13165 PyObject *arg3 = (PyObject *) 0 ;
13166 void *argp1 = 0 ;
13167 int res1 = 0 ;
13168 PyObject * obj0 = 0 ;
13169 PyObject * obj1 = 0 ;
13170 PyObject * obj2 = 0 ;
13171 char * kwnames[] = {
13172 (char *) "self",(char *) "self",(char *) "_class", NULL
13173 };
13174
13175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13177 if (!SWIG_IsOK(res1)) {
13178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13179 }
13180 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13181 arg2 = obj1;
13182 arg3 = obj2;
13183 {
13184 PyThreadState* __tstate = wxPyBeginAllowThreads();
13185 (arg1)->_setCallbackInfo(arg2,arg3);
13186 wxPyEndAllowThreads(__tstate);
13187 if (PyErr_Occurred()) SWIG_fail;
13188 }
13189 resultobj = SWIG_Py_Void();
13190 return resultobj;
13191 fail:
13192 return NULL;
13193 }
13194
13195
13196 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13197 PyObject *resultobj = 0;
13198 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13199 int arg2 ;
13200 int arg3 ;
13201 void *argp1 = 0 ;
13202 int res1 = 0 ;
13203 int val2 ;
13204 int ecode2 = 0 ;
13205 int val3 ;
13206 int ecode3 = 0 ;
13207 PyObject * obj0 = 0 ;
13208 PyObject * obj1 = 0 ;
13209 PyObject * obj2 = 0 ;
13210 char * kwnames[] = {
13211 (char *) "self",(char *) "pid",(char *) "status", NULL
13212 };
13213
13214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13216 if (!SWIG_IsOK(res1)) {
13217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13218 }
13219 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13220 ecode2 = SWIG_AsVal_int(obj1, &val2);
13221 if (!SWIG_IsOK(ecode2)) {
13222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13223 }
13224 arg2 = static_cast< int >(val2);
13225 ecode3 = SWIG_AsVal_int(obj2, &val3);
13226 if (!SWIG_IsOK(ecode3)) {
13227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13228 }
13229 arg3 = static_cast< int >(val3);
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 (arg1)->OnTerminate(arg2,arg3);
13233 wxPyEndAllowThreads(__tstate);
13234 if (PyErr_Occurred()) SWIG_fail;
13235 }
13236 resultobj = SWIG_Py_Void();
13237 return resultobj;
13238 fail:
13239 return NULL;
13240 }
13241
13242
13243 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13244 PyObject *resultobj = 0;
13245 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13246 void *argp1 = 0 ;
13247 int res1 = 0 ;
13248 PyObject *swig_obj[1] ;
13249
13250 if (!args) SWIG_fail;
13251 swig_obj[0] = args;
13252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13253 if (!SWIG_IsOK(res1)) {
13254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13255 }
13256 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13257 {
13258 PyThreadState* __tstate = wxPyBeginAllowThreads();
13259 (arg1)->Redirect();
13260 wxPyEndAllowThreads(__tstate);
13261 if (PyErr_Occurred()) SWIG_fail;
13262 }
13263 resultobj = SWIG_Py_Void();
13264 return resultobj;
13265 fail:
13266 return NULL;
13267 }
13268
13269
13270 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13271 PyObject *resultobj = 0;
13272 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13273 bool result;
13274 void *argp1 = 0 ;
13275 int res1 = 0 ;
13276 PyObject *swig_obj[1] ;
13277
13278 if (!args) SWIG_fail;
13279 swig_obj[0] = args;
13280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13281 if (!SWIG_IsOK(res1)) {
13282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13283 }
13284 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13285 {
13286 PyThreadState* __tstate = wxPyBeginAllowThreads();
13287 result = (bool)(arg1)->IsRedirected();
13288 wxPyEndAllowThreads(__tstate);
13289 if (PyErr_Occurred()) SWIG_fail;
13290 }
13291 {
13292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13293 }
13294 return resultobj;
13295 fail:
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13301 PyObject *resultobj = 0;
13302 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13303 void *argp1 = 0 ;
13304 int res1 = 0 ;
13305 PyObject *swig_obj[1] ;
13306
13307 if (!args) SWIG_fail;
13308 swig_obj[0] = args;
13309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13310 if (!SWIG_IsOK(res1)) {
13311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13312 }
13313 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 (arg1)->Detach();
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 resultobj = SWIG_Py_Void();
13321 return resultobj;
13322 fail:
13323 return NULL;
13324 }
13325
13326
13327 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13328 PyObject *resultobj = 0;
13329 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13330 wxInputStream *result = 0 ;
13331 void *argp1 = 0 ;
13332 int res1 = 0 ;
13333 PyObject *swig_obj[1] ;
13334
13335 if (!args) SWIG_fail;
13336 swig_obj[0] = args;
13337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13338 if (!SWIG_IsOK(res1)) {
13339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13340 }
13341 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13342 {
13343 PyThreadState* __tstate = wxPyBeginAllowThreads();
13344 result = (wxInputStream *)(arg1)->GetInputStream();
13345 wxPyEndAllowThreads(__tstate);
13346 if (PyErr_Occurred()) SWIG_fail;
13347 }
13348 {
13349 wxPyInputStream * _ptr = NULL;
13350
13351 if (result) {
13352 _ptr = new wxPyInputStream(result);
13353 }
13354 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13355 }
13356 return resultobj;
13357 fail:
13358 return NULL;
13359 }
13360
13361
13362 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13363 PyObject *resultobj = 0;
13364 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13365 wxInputStream *result = 0 ;
13366 void *argp1 = 0 ;
13367 int res1 = 0 ;
13368 PyObject *swig_obj[1] ;
13369
13370 if (!args) SWIG_fail;
13371 swig_obj[0] = args;
13372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13373 if (!SWIG_IsOK(res1)) {
13374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13375 }
13376 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 result = (wxInputStream *)(arg1)->GetErrorStream();
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 {
13384 wxPyInputStream * _ptr = NULL;
13385
13386 if (result) {
13387 _ptr = new wxPyInputStream(result);
13388 }
13389 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13390 }
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13398 PyObject *resultobj = 0;
13399 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13400 wxOutputStream *result = 0 ;
13401 void *argp1 = 0 ;
13402 int res1 = 0 ;
13403 PyObject *swig_obj[1] ;
13404
13405 if (!args) SWIG_fail;
13406 swig_obj[0] = args;
13407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13408 if (!SWIG_IsOK(res1)) {
13409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13410 }
13411 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13412 {
13413 PyThreadState* __tstate = wxPyBeginAllowThreads();
13414 result = (wxOutputStream *)(arg1)->GetOutputStream();
13415 wxPyEndAllowThreads(__tstate);
13416 if (PyErr_Occurred()) SWIG_fail;
13417 }
13418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13419 return resultobj;
13420 fail:
13421 return NULL;
13422 }
13423
13424
13425 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13426 PyObject *resultobj = 0;
13427 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13428 void *argp1 = 0 ;
13429 int res1 = 0 ;
13430 PyObject *swig_obj[1] ;
13431
13432 if (!args) SWIG_fail;
13433 swig_obj[0] = args;
13434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13435 if (!SWIG_IsOK(res1)) {
13436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13437 }
13438 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13439 {
13440 PyThreadState* __tstate = wxPyBeginAllowThreads();
13441 (arg1)->CloseOutput();
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 resultobj = SWIG_Py_Void();
13446 return resultobj;
13447 fail:
13448 return NULL;
13449 }
13450
13451
13452 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13453 PyObject *resultobj = 0;
13454 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13455 bool result;
13456 void *argp1 = 0 ;
13457 int res1 = 0 ;
13458 PyObject *swig_obj[1] ;
13459
13460 if (!args) SWIG_fail;
13461 swig_obj[0] = args;
13462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13463 if (!SWIG_IsOK(res1)) {
13464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13465 }
13466 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13467 {
13468 PyThreadState* __tstate = wxPyBeginAllowThreads();
13469 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13470 wxPyEndAllowThreads(__tstate);
13471 if (PyErr_Occurred()) SWIG_fail;
13472 }
13473 {
13474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13475 }
13476 return resultobj;
13477 fail:
13478 return NULL;
13479 }
13480
13481
13482 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13483 PyObject *resultobj = 0;
13484 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13485 bool result;
13486 void *argp1 = 0 ;
13487 int res1 = 0 ;
13488 PyObject *swig_obj[1] ;
13489
13490 if (!args) SWIG_fail;
13491 swig_obj[0] = args;
13492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13493 if (!SWIG_IsOK(res1)) {
13494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13495 }
13496 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 {
13504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13505 }
13506 return resultobj;
13507 fail:
13508 return NULL;
13509 }
13510
13511
13512 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13513 PyObject *resultobj = 0;
13514 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13515 bool result;
13516 void *argp1 = 0 ;
13517 int res1 = 0 ;
13518 PyObject *swig_obj[1] ;
13519
13520 if (!args) SWIG_fail;
13521 swig_obj[0] = args;
13522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13523 if (!SWIG_IsOK(res1)) {
13524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13525 }
13526 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13527 {
13528 PyThreadState* __tstate = wxPyBeginAllowThreads();
13529 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13530 wxPyEndAllowThreads(__tstate);
13531 if (PyErr_Occurred()) SWIG_fail;
13532 }
13533 {
13534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13535 }
13536 return resultobj;
13537 fail:
13538 return NULL;
13539 }
13540
13541
13542 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13543 PyObject *obj;
13544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13545 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13546 return SWIG_Py_Void();
13547 }
13548
13549 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13550 return SWIG_Python_InitShadowInstance(args);
13551 }
13552
13553 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj = 0;
13555 int arg1 = (int) 0 ;
13556 int arg2 = (int) 0 ;
13557 int arg3 = (int) 0 ;
13558 wxProcessEvent *result = 0 ;
13559 int val1 ;
13560 int ecode1 = 0 ;
13561 int val2 ;
13562 int ecode2 = 0 ;
13563 int val3 ;
13564 int ecode3 = 0 ;
13565 PyObject * obj0 = 0 ;
13566 PyObject * obj1 = 0 ;
13567 PyObject * obj2 = 0 ;
13568 char * kwnames[] = {
13569 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13570 };
13571
13572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13573 if (obj0) {
13574 ecode1 = SWIG_AsVal_int(obj0, &val1);
13575 if (!SWIG_IsOK(ecode1)) {
13576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13577 }
13578 arg1 = static_cast< int >(val1);
13579 }
13580 if (obj1) {
13581 ecode2 = SWIG_AsVal_int(obj1, &val2);
13582 if (!SWIG_IsOK(ecode2)) {
13583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13584 }
13585 arg2 = static_cast< int >(val2);
13586 }
13587 if (obj2) {
13588 ecode3 = SWIG_AsVal_int(obj2, &val3);
13589 if (!SWIG_IsOK(ecode3)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13591 }
13592 arg3 = static_cast< int >(val3);
13593 }
13594 {
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13597 wxPyEndAllowThreads(__tstate);
13598 if (PyErr_Occurred()) SWIG_fail;
13599 }
13600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13601 return resultobj;
13602 fail:
13603 return NULL;
13604 }
13605
13606
13607 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13608 PyObject *resultobj = 0;
13609 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13610 int result;
13611 void *argp1 = 0 ;
13612 int res1 = 0 ;
13613 PyObject *swig_obj[1] ;
13614
13615 if (!args) SWIG_fail;
13616 swig_obj[0] = args;
13617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13618 if (!SWIG_IsOK(res1)) {
13619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13620 }
13621 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 result = (int)(arg1)->GetPid();
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 resultobj = SWIG_From_int(static_cast< int >(result));
13629 return resultobj;
13630 fail:
13631 return NULL;
13632 }
13633
13634
13635 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13636 PyObject *resultobj = 0;
13637 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13638 int result;
13639 void *argp1 = 0 ;
13640 int res1 = 0 ;
13641 PyObject *swig_obj[1] ;
13642
13643 if (!args) SWIG_fail;
13644 swig_obj[0] = args;
13645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13646 if (!SWIG_IsOK(res1)) {
13647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13648 }
13649 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13650 {
13651 PyThreadState* __tstate = wxPyBeginAllowThreads();
13652 result = (int)(arg1)->GetExitCode();
13653 wxPyEndAllowThreads(__tstate);
13654 if (PyErr_Occurred()) SWIG_fail;
13655 }
13656 resultobj = SWIG_From_int(static_cast< int >(result));
13657 return resultobj;
13658 fail:
13659 return NULL;
13660 }
13661
13662
13663 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13664 PyObject *resultobj = 0;
13665 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13666 int arg2 ;
13667 void *argp1 = 0 ;
13668 int res1 = 0 ;
13669 int val2 ;
13670 int ecode2 = 0 ;
13671 PyObject *swig_obj[2] ;
13672
13673 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13675 if (!SWIG_IsOK(res1)) {
13676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13677 }
13678 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13679 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13680 if (!SWIG_IsOK(ecode2)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13682 }
13683 arg2 = static_cast< int >(val2);
13684 if (arg1) (arg1)->m_pid = arg2;
13685
13686 resultobj = SWIG_Py_Void();
13687 return resultobj;
13688 fail:
13689 return NULL;
13690 }
13691
13692
13693 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13694 PyObject *resultobj = 0;
13695 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13696 int result;
13697 void *argp1 = 0 ;
13698 int res1 = 0 ;
13699 PyObject *swig_obj[1] ;
13700
13701 if (!args) SWIG_fail;
13702 swig_obj[0] = args;
13703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13704 if (!SWIG_IsOK(res1)) {
13705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13706 }
13707 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13708 result = (int) ((arg1)->m_pid);
13709 resultobj = SWIG_From_int(static_cast< int >(result));
13710 return resultobj;
13711 fail:
13712 return NULL;
13713 }
13714
13715
13716 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13717 PyObject *resultobj = 0;
13718 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13719 int arg2 ;
13720 void *argp1 = 0 ;
13721 int res1 = 0 ;
13722 int val2 ;
13723 int ecode2 = 0 ;
13724 PyObject *swig_obj[2] ;
13725
13726 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13728 if (!SWIG_IsOK(res1)) {
13729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13730 }
13731 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13732 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13733 if (!SWIG_IsOK(ecode2)) {
13734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13735 }
13736 arg2 = static_cast< int >(val2);
13737 if (arg1) (arg1)->m_exitcode = arg2;
13738
13739 resultobj = SWIG_Py_Void();
13740 return resultobj;
13741 fail:
13742 return NULL;
13743 }
13744
13745
13746 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13747 PyObject *resultobj = 0;
13748 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13749 int result;
13750 void *argp1 = 0 ;
13751 int res1 = 0 ;
13752 PyObject *swig_obj[1] ;
13753
13754 if (!args) SWIG_fail;
13755 swig_obj[0] = args;
13756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13757 if (!SWIG_IsOK(res1)) {
13758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13759 }
13760 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13761 result = (int) ((arg1)->m_exitcode);
13762 resultobj = SWIG_From_int(static_cast< int >(result));
13763 return resultobj;
13764 fail:
13765 return NULL;
13766 }
13767
13768
13769 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13770 PyObject *obj;
13771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13772 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13773 return SWIG_Py_Void();
13774 }
13775
13776 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13777 return SWIG_Python_InitShadowInstance(args);
13778 }
13779
13780 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13781 PyObject *resultobj = 0;
13782 wxString *arg1 = 0 ;
13783 int arg2 = (int) wxEXEC_ASYNC ;
13784 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13785 long result;
13786 bool temp1 = false ;
13787 int val2 ;
13788 int ecode2 = 0 ;
13789 void *argp3 = 0 ;
13790 int res3 = 0 ;
13791 PyObject * obj0 = 0 ;
13792 PyObject * obj1 = 0 ;
13793 PyObject * obj2 = 0 ;
13794 char * kwnames[] = {
13795 (char *) "command",(char *) "flags",(char *) "process", NULL
13796 };
13797
13798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13799 {
13800 arg1 = wxString_in_helper(obj0);
13801 if (arg1 == NULL) SWIG_fail;
13802 temp1 = true;
13803 }
13804 if (obj1) {
13805 ecode2 = SWIG_AsVal_int(obj1, &val2);
13806 if (!SWIG_IsOK(ecode2)) {
13807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13808 }
13809 arg2 = static_cast< int >(val2);
13810 }
13811 if (obj2) {
13812 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13813 if (!SWIG_IsOK(res3)) {
13814 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13815 }
13816 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13817 }
13818 {
13819 if (!wxPyCheckForApp()) SWIG_fail;
13820 PyThreadState* __tstate = wxPyBeginAllowThreads();
13821 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13822 wxPyEndAllowThreads(__tstate);
13823 if (PyErr_Occurred()) SWIG_fail;
13824 }
13825 resultobj = SWIG_From_long(static_cast< long >(result));
13826 {
13827 if (temp1)
13828 delete arg1;
13829 }
13830 return resultobj;
13831 fail:
13832 {
13833 if (temp1)
13834 delete arg1;
13835 }
13836 return NULL;
13837 }
13838
13839
13840 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13841 PyObject *resultobj = 0;
13842 long arg1 ;
13843 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13844 wxKillError *arg3 = (wxKillError *) 0 ;
13845 int arg4 = (int) wxKILL_NOCHILDREN ;
13846 int result;
13847 long val1 ;
13848 int ecode1 = 0 ;
13849 int val2 ;
13850 int ecode2 = 0 ;
13851 wxKillError temp3 ;
13852 int val4 ;
13853 int ecode4 = 0 ;
13854 PyObject * obj0 = 0 ;
13855 PyObject * obj1 = 0 ;
13856 PyObject * obj2 = 0 ;
13857 char * kwnames[] = {
13858 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13859 };
13860
13861 {
13862 arg3 = &temp3;
13863 }
13864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13865 ecode1 = SWIG_AsVal_long(obj0, &val1);
13866 if (!SWIG_IsOK(ecode1)) {
13867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13868 }
13869 arg1 = static_cast< long >(val1);
13870 if (obj1) {
13871 ecode2 = SWIG_AsVal_int(obj1, &val2);
13872 if (!SWIG_IsOK(ecode2)) {
13873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13874 }
13875 arg2 = static_cast< wxSignal >(val2);
13876 }
13877 if (obj2) {
13878 ecode4 = SWIG_AsVal_int(obj2, &val4);
13879 if (!SWIG_IsOK(ecode4)) {
13880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13881 }
13882 arg4 = static_cast< int >(val4);
13883 }
13884 {
13885 PyThreadState* __tstate = wxPyBeginAllowThreads();
13886 result = (int)wxKill(arg1,arg2,arg3,arg4);
13887 wxPyEndAllowThreads(__tstate);
13888 if (PyErr_Occurred()) SWIG_fail;
13889 }
13890 resultobj = SWIG_From_int(static_cast< int >(result));
13891 {
13892 PyObject* o;
13893 o = PyInt_FromLong((long) (*arg3));
13894
13895
13896
13897 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13898
13899 }
13900 return resultobj;
13901 fail:
13902 return NULL;
13903 }
13904
13905
13906 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13907 PyObject *resultobj = 0;
13908 int arg1 = (int) wxJOYSTICK1 ;
13909 wxJoystick *result = 0 ;
13910 int val1 ;
13911 int ecode1 = 0 ;
13912 PyObject * obj0 = 0 ;
13913 char * kwnames[] = {
13914 (char *) "joystick", NULL
13915 };
13916
13917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13918 if (obj0) {
13919 ecode1 = SWIG_AsVal_int(obj0, &val1);
13920 if (!SWIG_IsOK(ecode1)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13922 }
13923 arg1 = static_cast< int >(val1);
13924 }
13925 {
13926 if (!wxPyCheckForApp()) SWIG_fail;
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 result = (wxJoystick *)new wxJoystick(arg1);
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13933 return resultobj;
13934 fail:
13935 return NULL;
13936 }
13937
13938
13939 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13940 PyObject *resultobj = 0;
13941 wxJoystick *arg1 = (wxJoystick *) 0 ;
13942 void *argp1 = 0 ;
13943 int res1 = 0 ;
13944 PyObject *swig_obj[1] ;
13945
13946 if (!args) SWIG_fail;
13947 swig_obj[0] = args;
13948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13949 if (!SWIG_IsOK(res1)) {
13950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13951 }
13952 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 delete arg1;
13956
13957 wxPyEndAllowThreads(__tstate);
13958 if (PyErr_Occurred()) SWIG_fail;
13959 }
13960 resultobj = SWIG_Py_Void();
13961 return resultobj;
13962 fail:
13963 return NULL;
13964 }
13965
13966
13967 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13968 PyObject *resultobj = 0;
13969 wxJoystick *arg1 = (wxJoystick *) 0 ;
13970 wxPoint result;
13971 void *argp1 = 0 ;
13972 int res1 = 0 ;
13973 PyObject *swig_obj[1] ;
13974
13975 if (!args) SWIG_fail;
13976 swig_obj[0] = args;
13977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13978 if (!SWIG_IsOK(res1)) {
13979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13980 }
13981 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13982 {
13983 PyThreadState* __tstate = wxPyBeginAllowThreads();
13984 result = (arg1)->GetPosition();
13985 wxPyEndAllowThreads(__tstate);
13986 if (PyErr_Occurred()) SWIG_fail;
13987 }
13988 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13989 return resultobj;
13990 fail:
13991 return NULL;
13992 }
13993
13994
13995 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13996 PyObject *resultobj = 0;
13997 wxJoystick *arg1 = (wxJoystick *) 0 ;
13998 int result;
13999 void *argp1 = 0 ;
14000 int res1 = 0 ;
14001 PyObject *swig_obj[1] ;
14002
14003 if (!args) SWIG_fail;
14004 swig_obj[0] = args;
14005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14006 if (!SWIG_IsOK(res1)) {
14007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14008 }
14009 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14010 {
14011 PyThreadState* __tstate = wxPyBeginAllowThreads();
14012 result = (int)(arg1)->GetZPosition();
14013 wxPyEndAllowThreads(__tstate);
14014 if (PyErr_Occurred()) SWIG_fail;
14015 }
14016 resultobj = SWIG_From_int(static_cast< int >(result));
14017 return resultobj;
14018 fail:
14019 return NULL;
14020 }
14021
14022
14023 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14024 PyObject *resultobj = 0;
14025 wxJoystick *arg1 = (wxJoystick *) 0 ;
14026 int result;
14027 void *argp1 = 0 ;
14028 int res1 = 0 ;
14029 PyObject *swig_obj[1] ;
14030
14031 if (!args) SWIG_fail;
14032 swig_obj[0] = args;
14033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14034 if (!SWIG_IsOK(res1)) {
14035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14036 }
14037 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14038 {
14039 PyThreadState* __tstate = wxPyBeginAllowThreads();
14040 result = (int)(arg1)->GetButtonState();
14041 wxPyEndAllowThreads(__tstate);
14042 if (PyErr_Occurred()) SWIG_fail;
14043 }
14044 resultobj = SWIG_From_int(static_cast< int >(result));
14045 return resultobj;
14046 fail:
14047 return NULL;
14048 }
14049
14050
14051 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14052 PyObject *resultobj = 0;
14053 wxJoystick *arg1 = (wxJoystick *) 0 ;
14054 int result;
14055 void *argp1 = 0 ;
14056 int res1 = 0 ;
14057 PyObject *swig_obj[1] ;
14058
14059 if (!args) SWIG_fail;
14060 swig_obj[0] = args;
14061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14062 if (!SWIG_IsOK(res1)) {
14063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14064 }
14065 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 result = (int)(arg1)->GetPOVPosition();
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 resultobj = SWIG_From_int(static_cast< int >(result));
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14080 PyObject *resultobj = 0;
14081 wxJoystick *arg1 = (wxJoystick *) 0 ;
14082 int result;
14083 void *argp1 = 0 ;
14084 int res1 = 0 ;
14085 PyObject *swig_obj[1] ;
14086
14087 if (!args) SWIG_fail;
14088 swig_obj[0] = args;
14089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14090 if (!SWIG_IsOK(res1)) {
14091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14092 }
14093 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14094 {
14095 PyThreadState* __tstate = wxPyBeginAllowThreads();
14096 result = (int)(arg1)->GetPOVCTSPosition();
14097 wxPyEndAllowThreads(__tstate);
14098 if (PyErr_Occurred()) SWIG_fail;
14099 }
14100 resultobj = SWIG_From_int(static_cast< int >(result));
14101 return resultobj;
14102 fail:
14103 return NULL;
14104 }
14105
14106
14107 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14108 PyObject *resultobj = 0;
14109 wxJoystick *arg1 = (wxJoystick *) 0 ;
14110 int result;
14111 void *argp1 = 0 ;
14112 int res1 = 0 ;
14113 PyObject *swig_obj[1] ;
14114
14115 if (!args) SWIG_fail;
14116 swig_obj[0] = args;
14117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14118 if (!SWIG_IsOK(res1)) {
14119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14120 }
14121 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14122 {
14123 PyThreadState* __tstate = wxPyBeginAllowThreads();
14124 result = (int)(arg1)->GetRudderPosition();
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 resultobj = SWIG_From_int(static_cast< int >(result));
14129 return resultobj;
14130 fail:
14131 return NULL;
14132 }
14133
14134
14135 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14136 PyObject *resultobj = 0;
14137 wxJoystick *arg1 = (wxJoystick *) 0 ;
14138 int result;
14139 void *argp1 = 0 ;
14140 int res1 = 0 ;
14141 PyObject *swig_obj[1] ;
14142
14143 if (!args) SWIG_fail;
14144 swig_obj[0] = args;
14145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14146 if (!SWIG_IsOK(res1)) {
14147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14148 }
14149 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 result = (int)(arg1)->GetUPosition();
14153 wxPyEndAllowThreads(__tstate);
14154 if (PyErr_Occurred()) SWIG_fail;
14155 }
14156 resultobj = SWIG_From_int(static_cast< int >(result));
14157 return resultobj;
14158 fail:
14159 return NULL;
14160 }
14161
14162
14163 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14164 PyObject *resultobj = 0;
14165 wxJoystick *arg1 = (wxJoystick *) 0 ;
14166 int result;
14167 void *argp1 = 0 ;
14168 int res1 = 0 ;
14169 PyObject *swig_obj[1] ;
14170
14171 if (!args) SWIG_fail;
14172 swig_obj[0] = args;
14173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14174 if (!SWIG_IsOK(res1)) {
14175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14176 }
14177 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14178 {
14179 PyThreadState* __tstate = wxPyBeginAllowThreads();
14180 result = (int)(arg1)->GetVPosition();
14181 wxPyEndAllowThreads(__tstate);
14182 if (PyErr_Occurred()) SWIG_fail;
14183 }
14184 resultobj = SWIG_From_int(static_cast< int >(result));
14185 return resultobj;
14186 fail:
14187 return NULL;
14188 }
14189
14190
14191 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14192 PyObject *resultobj = 0;
14193 wxJoystick *arg1 = (wxJoystick *) 0 ;
14194 int result;
14195 void *argp1 = 0 ;
14196 int res1 = 0 ;
14197 PyObject *swig_obj[1] ;
14198
14199 if (!args) SWIG_fail;
14200 swig_obj[0] = args;
14201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14202 if (!SWIG_IsOK(res1)) {
14203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14204 }
14205 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14206 {
14207 PyThreadState* __tstate = wxPyBeginAllowThreads();
14208 result = (int)(arg1)->GetMovementThreshold();
14209 wxPyEndAllowThreads(__tstate);
14210 if (PyErr_Occurred()) SWIG_fail;
14211 }
14212 resultobj = SWIG_From_int(static_cast< int >(result));
14213 return resultobj;
14214 fail:
14215 return NULL;
14216 }
14217
14218
14219 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14220 PyObject *resultobj = 0;
14221 wxJoystick *arg1 = (wxJoystick *) 0 ;
14222 int arg2 ;
14223 void *argp1 = 0 ;
14224 int res1 = 0 ;
14225 int val2 ;
14226 int ecode2 = 0 ;
14227 PyObject * obj0 = 0 ;
14228 PyObject * obj1 = 0 ;
14229 char * kwnames[] = {
14230 (char *) "self",(char *) "threshold", NULL
14231 };
14232
14233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14235 if (!SWIG_IsOK(res1)) {
14236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14237 }
14238 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14239 ecode2 = SWIG_AsVal_int(obj1, &val2);
14240 if (!SWIG_IsOK(ecode2)) {
14241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14242 }
14243 arg2 = static_cast< int >(val2);
14244 {
14245 PyThreadState* __tstate = wxPyBeginAllowThreads();
14246 (arg1)->SetMovementThreshold(arg2);
14247 wxPyEndAllowThreads(__tstate);
14248 if (PyErr_Occurred()) SWIG_fail;
14249 }
14250 resultobj = SWIG_Py_Void();
14251 return resultobj;
14252 fail:
14253 return NULL;
14254 }
14255
14256
14257 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14258 PyObject *resultobj = 0;
14259 wxJoystick *arg1 = (wxJoystick *) 0 ;
14260 bool result;
14261 void *argp1 = 0 ;
14262 int res1 = 0 ;
14263 PyObject *swig_obj[1] ;
14264
14265 if (!args) SWIG_fail;
14266 swig_obj[0] = args;
14267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14268 if (!SWIG_IsOK(res1)) {
14269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14270 }
14271 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 result = (bool)(arg1)->IsOk();
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 {
14279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14280 }
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14288 PyObject *resultobj = 0;
14289 wxJoystick *arg1 = (wxJoystick *) 0 ;
14290 int result;
14291 void *argp1 = 0 ;
14292 int res1 = 0 ;
14293 PyObject *swig_obj[1] ;
14294
14295 if (!args) SWIG_fail;
14296 swig_obj[0] = args;
14297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14298 if (!SWIG_IsOK(res1)) {
14299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14300 }
14301 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 result = (int)(arg1)->GetNumberJoysticks();
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 resultobj = SWIG_From_int(static_cast< int >(result));
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14316 PyObject *resultobj = 0;
14317 wxJoystick *arg1 = (wxJoystick *) 0 ;
14318 int result;
14319 void *argp1 = 0 ;
14320 int res1 = 0 ;
14321 PyObject *swig_obj[1] ;
14322
14323 if (!args) SWIG_fail;
14324 swig_obj[0] = args;
14325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14326 if (!SWIG_IsOK(res1)) {
14327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14328 }
14329 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14330 {
14331 PyThreadState* __tstate = wxPyBeginAllowThreads();
14332 result = (int)(arg1)->GetManufacturerId();
14333 wxPyEndAllowThreads(__tstate);
14334 if (PyErr_Occurred()) SWIG_fail;
14335 }
14336 resultobj = SWIG_From_int(static_cast< int >(result));
14337 return resultobj;
14338 fail:
14339 return NULL;
14340 }
14341
14342
14343 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14344 PyObject *resultobj = 0;
14345 wxJoystick *arg1 = (wxJoystick *) 0 ;
14346 int result;
14347 void *argp1 = 0 ;
14348 int res1 = 0 ;
14349 PyObject *swig_obj[1] ;
14350
14351 if (!args) SWIG_fail;
14352 swig_obj[0] = args;
14353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14354 if (!SWIG_IsOK(res1)) {
14355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14356 }
14357 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (int)(arg1)->GetProductId();
14361 wxPyEndAllowThreads(__tstate);
14362 if (PyErr_Occurred()) SWIG_fail;
14363 }
14364 resultobj = SWIG_From_int(static_cast< int >(result));
14365 return resultobj;
14366 fail:
14367 return NULL;
14368 }
14369
14370
14371 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14372 PyObject *resultobj = 0;
14373 wxJoystick *arg1 = (wxJoystick *) 0 ;
14374 wxString result;
14375 void *argp1 = 0 ;
14376 int res1 = 0 ;
14377 PyObject *swig_obj[1] ;
14378
14379 if (!args) SWIG_fail;
14380 swig_obj[0] = args;
14381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14382 if (!SWIG_IsOK(res1)) {
14383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14384 }
14385 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14386 {
14387 PyThreadState* __tstate = wxPyBeginAllowThreads();
14388 result = (arg1)->GetProductName();
14389 wxPyEndAllowThreads(__tstate);
14390 if (PyErr_Occurred()) SWIG_fail;
14391 }
14392 {
14393 #if wxUSE_UNICODE
14394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14395 #else
14396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14397 #endif
14398 }
14399 return resultobj;
14400 fail:
14401 return NULL;
14402 }
14403
14404
14405 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14406 PyObject *resultobj = 0;
14407 wxJoystick *arg1 = (wxJoystick *) 0 ;
14408 int result;
14409 void *argp1 = 0 ;
14410 int res1 = 0 ;
14411 PyObject *swig_obj[1] ;
14412
14413 if (!args) SWIG_fail;
14414 swig_obj[0] = args;
14415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14416 if (!SWIG_IsOK(res1)) {
14417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14418 }
14419 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14420 {
14421 PyThreadState* __tstate = wxPyBeginAllowThreads();
14422 result = (int)(arg1)->GetXMin();
14423 wxPyEndAllowThreads(__tstate);
14424 if (PyErr_Occurred()) SWIG_fail;
14425 }
14426 resultobj = SWIG_From_int(static_cast< int >(result));
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14434 PyObject *resultobj = 0;
14435 wxJoystick *arg1 = (wxJoystick *) 0 ;
14436 int result;
14437 void *argp1 = 0 ;
14438 int res1 = 0 ;
14439 PyObject *swig_obj[1] ;
14440
14441 if (!args) SWIG_fail;
14442 swig_obj[0] = args;
14443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14444 if (!SWIG_IsOK(res1)) {
14445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14446 }
14447 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14448 {
14449 PyThreadState* __tstate = wxPyBeginAllowThreads();
14450 result = (int)(arg1)->GetYMin();
14451 wxPyEndAllowThreads(__tstate);
14452 if (PyErr_Occurred()) SWIG_fail;
14453 }
14454 resultobj = SWIG_From_int(static_cast< int >(result));
14455 return resultobj;
14456 fail:
14457 return NULL;
14458 }
14459
14460
14461 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14462 PyObject *resultobj = 0;
14463 wxJoystick *arg1 = (wxJoystick *) 0 ;
14464 int result;
14465 void *argp1 = 0 ;
14466 int res1 = 0 ;
14467 PyObject *swig_obj[1] ;
14468
14469 if (!args) SWIG_fail;
14470 swig_obj[0] = args;
14471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14472 if (!SWIG_IsOK(res1)) {
14473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14474 }
14475 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 result = (int)(arg1)->GetZMin();
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 resultobj = SWIG_From_int(static_cast< int >(result));
14483 return resultobj;
14484 fail:
14485 return NULL;
14486 }
14487
14488
14489 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14490 PyObject *resultobj = 0;
14491 wxJoystick *arg1 = (wxJoystick *) 0 ;
14492 int result;
14493 void *argp1 = 0 ;
14494 int res1 = 0 ;
14495 PyObject *swig_obj[1] ;
14496
14497 if (!args) SWIG_fail;
14498 swig_obj[0] = args;
14499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14500 if (!SWIG_IsOK(res1)) {
14501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14502 }
14503 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14504 {
14505 PyThreadState* __tstate = wxPyBeginAllowThreads();
14506 result = (int)(arg1)->GetXMax();
14507 wxPyEndAllowThreads(__tstate);
14508 if (PyErr_Occurred()) SWIG_fail;
14509 }
14510 resultobj = SWIG_From_int(static_cast< int >(result));
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14518 PyObject *resultobj = 0;
14519 wxJoystick *arg1 = (wxJoystick *) 0 ;
14520 int result;
14521 void *argp1 = 0 ;
14522 int res1 = 0 ;
14523 PyObject *swig_obj[1] ;
14524
14525 if (!args) SWIG_fail;
14526 swig_obj[0] = args;
14527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14528 if (!SWIG_IsOK(res1)) {
14529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14530 }
14531 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14532 {
14533 PyThreadState* __tstate = wxPyBeginAllowThreads();
14534 result = (int)(arg1)->GetYMax();
14535 wxPyEndAllowThreads(__tstate);
14536 if (PyErr_Occurred()) SWIG_fail;
14537 }
14538 resultobj = SWIG_From_int(static_cast< int >(result));
14539 return resultobj;
14540 fail:
14541 return NULL;
14542 }
14543
14544
14545 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14546 PyObject *resultobj = 0;
14547 wxJoystick *arg1 = (wxJoystick *) 0 ;
14548 int result;
14549 void *argp1 = 0 ;
14550 int res1 = 0 ;
14551 PyObject *swig_obj[1] ;
14552
14553 if (!args) SWIG_fail;
14554 swig_obj[0] = args;
14555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14556 if (!SWIG_IsOK(res1)) {
14557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14558 }
14559 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14560 {
14561 PyThreadState* __tstate = wxPyBeginAllowThreads();
14562 result = (int)(arg1)->GetZMax();
14563 wxPyEndAllowThreads(__tstate);
14564 if (PyErr_Occurred()) SWIG_fail;
14565 }
14566 resultobj = SWIG_From_int(static_cast< int >(result));
14567 return resultobj;
14568 fail:
14569 return NULL;
14570 }
14571
14572
14573 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14574 PyObject *resultobj = 0;
14575 wxJoystick *arg1 = (wxJoystick *) 0 ;
14576 int result;
14577 void *argp1 = 0 ;
14578 int res1 = 0 ;
14579 PyObject *swig_obj[1] ;
14580
14581 if (!args) SWIG_fail;
14582 swig_obj[0] = args;
14583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14584 if (!SWIG_IsOK(res1)) {
14585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14586 }
14587 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 result = (int)(arg1)->GetNumberButtons();
14591 wxPyEndAllowThreads(__tstate);
14592 if (PyErr_Occurred()) SWIG_fail;
14593 }
14594 resultobj = SWIG_From_int(static_cast< int >(result));
14595 return resultobj;
14596 fail:
14597 return NULL;
14598 }
14599
14600
14601 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14602 PyObject *resultobj = 0;
14603 wxJoystick *arg1 = (wxJoystick *) 0 ;
14604 int result;
14605 void *argp1 = 0 ;
14606 int res1 = 0 ;
14607 PyObject *swig_obj[1] ;
14608
14609 if (!args) SWIG_fail;
14610 swig_obj[0] = args;
14611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14612 if (!SWIG_IsOK(res1)) {
14613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14614 }
14615 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 result = (int)(arg1)->GetNumberAxes();
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 resultobj = SWIG_From_int(static_cast< int >(result));
14623 return resultobj;
14624 fail:
14625 return NULL;
14626 }
14627
14628
14629 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14630 PyObject *resultobj = 0;
14631 wxJoystick *arg1 = (wxJoystick *) 0 ;
14632 int result;
14633 void *argp1 = 0 ;
14634 int res1 = 0 ;
14635 PyObject *swig_obj[1] ;
14636
14637 if (!args) SWIG_fail;
14638 swig_obj[0] = args;
14639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14640 if (!SWIG_IsOK(res1)) {
14641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14642 }
14643 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 result = (int)(arg1)->GetMaxButtons();
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 resultobj = SWIG_From_int(static_cast< int >(result));
14651 return resultobj;
14652 fail:
14653 return NULL;
14654 }
14655
14656
14657 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14658 PyObject *resultobj = 0;
14659 wxJoystick *arg1 = (wxJoystick *) 0 ;
14660 int result;
14661 void *argp1 = 0 ;
14662 int res1 = 0 ;
14663 PyObject *swig_obj[1] ;
14664
14665 if (!args) SWIG_fail;
14666 swig_obj[0] = args;
14667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14668 if (!SWIG_IsOK(res1)) {
14669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14670 }
14671 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14672 {
14673 PyThreadState* __tstate = wxPyBeginAllowThreads();
14674 result = (int)(arg1)->GetMaxAxes();
14675 wxPyEndAllowThreads(__tstate);
14676 if (PyErr_Occurred()) SWIG_fail;
14677 }
14678 resultobj = SWIG_From_int(static_cast< int >(result));
14679 return resultobj;
14680 fail:
14681 return NULL;
14682 }
14683
14684
14685 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14686 PyObject *resultobj = 0;
14687 wxJoystick *arg1 = (wxJoystick *) 0 ;
14688 int result;
14689 void *argp1 = 0 ;
14690 int res1 = 0 ;
14691 PyObject *swig_obj[1] ;
14692
14693 if (!args) SWIG_fail;
14694 swig_obj[0] = args;
14695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14696 if (!SWIG_IsOK(res1)) {
14697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14698 }
14699 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14700 {
14701 PyThreadState* __tstate = wxPyBeginAllowThreads();
14702 result = (int)(arg1)->GetPollingMin();
14703 wxPyEndAllowThreads(__tstate);
14704 if (PyErr_Occurred()) SWIG_fail;
14705 }
14706 resultobj = SWIG_From_int(static_cast< int >(result));
14707 return resultobj;
14708 fail:
14709 return NULL;
14710 }
14711
14712
14713 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14714 PyObject *resultobj = 0;
14715 wxJoystick *arg1 = (wxJoystick *) 0 ;
14716 int result;
14717 void *argp1 = 0 ;
14718 int res1 = 0 ;
14719 PyObject *swig_obj[1] ;
14720
14721 if (!args) SWIG_fail;
14722 swig_obj[0] = args;
14723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14724 if (!SWIG_IsOK(res1)) {
14725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14726 }
14727 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14728 {
14729 PyThreadState* __tstate = wxPyBeginAllowThreads();
14730 result = (int)(arg1)->GetPollingMax();
14731 wxPyEndAllowThreads(__tstate);
14732 if (PyErr_Occurred()) SWIG_fail;
14733 }
14734 resultobj = SWIG_From_int(static_cast< int >(result));
14735 return resultobj;
14736 fail:
14737 return NULL;
14738 }
14739
14740
14741 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14742 PyObject *resultobj = 0;
14743 wxJoystick *arg1 = (wxJoystick *) 0 ;
14744 int result;
14745 void *argp1 = 0 ;
14746 int res1 = 0 ;
14747 PyObject *swig_obj[1] ;
14748
14749 if (!args) SWIG_fail;
14750 swig_obj[0] = args;
14751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14752 if (!SWIG_IsOK(res1)) {
14753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14754 }
14755 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14756 {
14757 PyThreadState* __tstate = wxPyBeginAllowThreads();
14758 result = (int)(arg1)->GetRudderMin();
14759 wxPyEndAllowThreads(__tstate);
14760 if (PyErr_Occurred()) SWIG_fail;
14761 }
14762 resultobj = SWIG_From_int(static_cast< int >(result));
14763 return resultobj;
14764 fail:
14765 return NULL;
14766 }
14767
14768
14769 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14770 PyObject *resultobj = 0;
14771 wxJoystick *arg1 = (wxJoystick *) 0 ;
14772 int result;
14773 void *argp1 = 0 ;
14774 int res1 = 0 ;
14775 PyObject *swig_obj[1] ;
14776
14777 if (!args) SWIG_fail;
14778 swig_obj[0] = args;
14779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14780 if (!SWIG_IsOK(res1)) {
14781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14782 }
14783 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (int)(arg1)->GetRudderMax();
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 resultobj = SWIG_From_int(static_cast< int >(result));
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14798 PyObject *resultobj = 0;
14799 wxJoystick *arg1 = (wxJoystick *) 0 ;
14800 int result;
14801 void *argp1 = 0 ;
14802 int res1 = 0 ;
14803 PyObject *swig_obj[1] ;
14804
14805 if (!args) SWIG_fail;
14806 swig_obj[0] = args;
14807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14808 if (!SWIG_IsOK(res1)) {
14809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14810 }
14811 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14812 {
14813 PyThreadState* __tstate = wxPyBeginAllowThreads();
14814 result = (int)(arg1)->GetUMin();
14815 wxPyEndAllowThreads(__tstate);
14816 if (PyErr_Occurred()) SWIG_fail;
14817 }
14818 resultobj = SWIG_From_int(static_cast< int >(result));
14819 return resultobj;
14820 fail:
14821 return NULL;
14822 }
14823
14824
14825 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14826 PyObject *resultobj = 0;
14827 wxJoystick *arg1 = (wxJoystick *) 0 ;
14828 int result;
14829 void *argp1 = 0 ;
14830 int res1 = 0 ;
14831 PyObject *swig_obj[1] ;
14832
14833 if (!args) SWIG_fail;
14834 swig_obj[0] = args;
14835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14838 }
14839 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 result = (int)(arg1)->GetUMax();
14843 wxPyEndAllowThreads(__tstate);
14844 if (PyErr_Occurred()) SWIG_fail;
14845 }
14846 resultobj = SWIG_From_int(static_cast< int >(result));
14847 return resultobj;
14848 fail:
14849 return NULL;
14850 }
14851
14852
14853 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14854 PyObject *resultobj = 0;
14855 wxJoystick *arg1 = (wxJoystick *) 0 ;
14856 int result;
14857 void *argp1 = 0 ;
14858 int res1 = 0 ;
14859 PyObject *swig_obj[1] ;
14860
14861 if (!args) SWIG_fail;
14862 swig_obj[0] = args;
14863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14864 if (!SWIG_IsOK(res1)) {
14865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14866 }
14867 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 result = (int)(arg1)->GetVMin();
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 resultobj = SWIG_From_int(static_cast< int >(result));
14875 return resultobj;
14876 fail:
14877 return NULL;
14878 }
14879
14880
14881 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14882 PyObject *resultobj = 0;
14883 wxJoystick *arg1 = (wxJoystick *) 0 ;
14884 int result;
14885 void *argp1 = 0 ;
14886 int res1 = 0 ;
14887 PyObject *swig_obj[1] ;
14888
14889 if (!args) SWIG_fail;
14890 swig_obj[0] = args;
14891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14892 if (!SWIG_IsOK(res1)) {
14893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14894 }
14895 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14896 {
14897 PyThreadState* __tstate = wxPyBeginAllowThreads();
14898 result = (int)(arg1)->GetVMax();
14899 wxPyEndAllowThreads(__tstate);
14900 if (PyErr_Occurred()) SWIG_fail;
14901 }
14902 resultobj = SWIG_From_int(static_cast< int >(result));
14903 return resultobj;
14904 fail:
14905 return NULL;
14906 }
14907
14908
14909 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14910 PyObject *resultobj = 0;
14911 wxJoystick *arg1 = (wxJoystick *) 0 ;
14912 bool result;
14913 void *argp1 = 0 ;
14914 int res1 = 0 ;
14915 PyObject *swig_obj[1] ;
14916
14917 if (!args) SWIG_fail;
14918 swig_obj[0] = args;
14919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14920 if (!SWIG_IsOK(res1)) {
14921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14922 }
14923 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14924 {
14925 PyThreadState* __tstate = wxPyBeginAllowThreads();
14926 result = (bool)(arg1)->HasRudder();
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 {
14931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14932 }
14933 return resultobj;
14934 fail:
14935 return NULL;
14936 }
14937
14938
14939 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14940 PyObject *resultobj = 0;
14941 wxJoystick *arg1 = (wxJoystick *) 0 ;
14942 bool result;
14943 void *argp1 = 0 ;
14944 int res1 = 0 ;
14945 PyObject *swig_obj[1] ;
14946
14947 if (!args) SWIG_fail;
14948 swig_obj[0] = args;
14949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14950 if (!SWIG_IsOK(res1)) {
14951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14952 }
14953 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 result = (bool)(arg1)->HasZ();
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 {
14961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14962 }
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14970 PyObject *resultobj = 0;
14971 wxJoystick *arg1 = (wxJoystick *) 0 ;
14972 bool result;
14973 void *argp1 = 0 ;
14974 int res1 = 0 ;
14975 PyObject *swig_obj[1] ;
14976
14977 if (!args) SWIG_fail;
14978 swig_obj[0] = args;
14979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14980 if (!SWIG_IsOK(res1)) {
14981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14982 }
14983 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14984 {
14985 PyThreadState* __tstate = wxPyBeginAllowThreads();
14986 result = (bool)(arg1)->HasU();
14987 wxPyEndAllowThreads(__tstate);
14988 if (PyErr_Occurred()) SWIG_fail;
14989 }
14990 {
14991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14992 }
14993 return resultobj;
14994 fail:
14995 return NULL;
14996 }
14997
14998
14999 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15000 PyObject *resultobj = 0;
15001 wxJoystick *arg1 = (wxJoystick *) 0 ;
15002 bool result;
15003 void *argp1 = 0 ;
15004 int res1 = 0 ;
15005 PyObject *swig_obj[1] ;
15006
15007 if (!args) SWIG_fail;
15008 swig_obj[0] = args;
15009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15010 if (!SWIG_IsOK(res1)) {
15011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15012 }
15013 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (bool)(arg1)->HasV();
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 {
15021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15022 }
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15030 PyObject *resultobj = 0;
15031 wxJoystick *arg1 = (wxJoystick *) 0 ;
15032 bool result;
15033 void *argp1 = 0 ;
15034 int res1 = 0 ;
15035 PyObject *swig_obj[1] ;
15036
15037 if (!args) SWIG_fail;
15038 swig_obj[0] = args;
15039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15040 if (!SWIG_IsOK(res1)) {
15041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15042 }
15043 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (bool)(arg1)->HasPOV();
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 {
15051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15052 }
15053 return resultobj;
15054 fail:
15055 return NULL;
15056 }
15057
15058
15059 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15060 PyObject *resultobj = 0;
15061 wxJoystick *arg1 = (wxJoystick *) 0 ;
15062 bool result;
15063 void *argp1 = 0 ;
15064 int res1 = 0 ;
15065 PyObject *swig_obj[1] ;
15066
15067 if (!args) SWIG_fail;
15068 swig_obj[0] = args;
15069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15070 if (!SWIG_IsOK(res1)) {
15071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15072 }
15073 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15074 {
15075 PyThreadState* __tstate = wxPyBeginAllowThreads();
15076 result = (bool)(arg1)->HasPOV4Dir();
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 {
15081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15082 }
15083 return resultobj;
15084 fail:
15085 return NULL;
15086 }
15087
15088
15089 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090 PyObject *resultobj = 0;
15091 wxJoystick *arg1 = (wxJoystick *) 0 ;
15092 bool result;
15093 void *argp1 = 0 ;
15094 int res1 = 0 ;
15095 PyObject *swig_obj[1] ;
15096
15097 if (!args) SWIG_fail;
15098 swig_obj[0] = args;
15099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15100 if (!SWIG_IsOK(res1)) {
15101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15102 }
15103 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 result = (bool)(arg1)->HasPOVCTS();
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 {
15111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15112 }
15113 return resultobj;
15114 fail:
15115 return NULL;
15116 }
15117
15118
15119 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15120 PyObject *resultobj = 0;
15121 wxJoystick *arg1 = (wxJoystick *) 0 ;
15122 wxWindow *arg2 = (wxWindow *) 0 ;
15123 int arg3 = (int) 0 ;
15124 bool result;
15125 void *argp1 = 0 ;
15126 int res1 = 0 ;
15127 void *argp2 = 0 ;
15128 int res2 = 0 ;
15129 int val3 ;
15130 int ecode3 = 0 ;
15131 PyObject * obj0 = 0 ;
15132 PyObject * obj1 = 0 ;
15133 PyObject * obj2 = 0 ;
15134 char * kwnames[] = {
15135 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15136 };
15137
15138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15140 if (!SWIG_IsOK(res1)) {
15141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15142 }
15143 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15145 if (!SWIG_IsOK(res2)) {
15146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15147 }
15148 arg2 = reinterpret_cast< wxWindow * >(argp2);
15149 if (obj2) {
15150 ecode3 = SWIG_AsVal_int(obj2, &val3);
15151 if (!SWIG_IsOK(ecode3)) {
15152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15153 }
15154 arg3 = static_cast< int >(val3);
15155 }
15156 {
15157 PyThreadState* __tstate = wxPyBeginAllowThreads();
15158 result = (bool)(arg1)->SetCapture(arg2,arg3);
15159 wxPyEndAllowThreads(__tstate);
15160 if (PyErr_Occurred()) SWIG_fail;
15161 }
15162 {
15163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15164 }
15165 return resultobj;
15166 fail:
15167 return NULL;
15168 }
15169
15170
15171 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15172 PyObject *resultobj = 0;
15173 wxJoystick *arg1 = (wxJoystick *) 0 ;
15174 bool result;
15175 void *argp1 = 0 ;
15176 int res1 = 0 ;
15177 PyObject *swig_obj[1] ;
15178
15179 if (!args) SWIG_fail;
15180 swig_obj[0] = args;
15181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15182 if (!SWIG_IsOK(res1)) {
15183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15184 }
15185 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = (bool)(arg1)->ReleaseCapture();
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 {
15193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15194 }
15195 return resultobj;
15196 fail:
15197 return NULL;
15198 }
15199
15200
15201 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15202 PyObject *obj;
15203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15204 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15205 return SWIG_Py_Void();
15206 }
15207
15208 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15209 return SWIG_Python_InitShadowInstance(args);
15210 }
15211
15212 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15213 PyObject *resultobj = 0;
15214 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15215 int arg2 = (int) 0 ;
15216 int arg3 = (int) wxJOYSTICK1 ;
15217 int arg4 = (int) 0 ;
15218 wxJoystickEvent *result = 0 ;
15219 int val1 ;
15220 int ecode1 = 0 ;
15221 int val2 ;
15222 int ecode2 = 0 ;
15223 int val3 ;
15224 int ecode3 = 0 ;
15225 int val4 ;
15226 int ecode4 = 0 ;
15227 PyObject * obj0 = 0 ;
15228 PyObject * obj1 = 0 ;
15229 PyObject * obj2 = 0 ;
15230 PyObject * obj3 = 0 ;
15231 char * kwnames[] = {
15232 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15233 };
15234
15235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15236 if (obj0) {
15237 ecode1 = SWIG_AsVal_int(obj0, &val1);
15238 if (!SWIG_IsOK(ecode1)) {
15239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15240 }
15241 arg1 = static_cast< wxEventType >(val1);
15242 }
15243 if (obj1) {
15244 ecode2 = SWIG_AsVal_int(obj1, &val2);
15245 if (!SWIG_IsOK(ecode2)) {
15246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15247 }
15248 arg2 = static_cast< int >(val2);
15249 }
15250 if (obj2) {
15251 ecode3 = SWIG_AsVal_int(obj2, &val3);
15252 if (!SWIG_IsOK(ecode3)) {
15253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15254 }
15255 arg3 = static_cast< int >(val3);
15256 }
15257 if (obj3) {
15258 ecode4 = SWIG_AsVal_int(obj3, &val4);
15259 if (!SWIG_IsOK(ecode4)) {
15260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15261 }
15262 arg4 = static_cast< int >(val4);
15263 }
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15271 return resultobj;
15272 fail:
15273 return NULL;
15274 }
15275
15276
15277 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15278 PyObject *resultobj = 0;
15279 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15280 wxPoint result;
15281 void *argp1 = 0 ;
15282 int res1 = 0 ;
15283 PyObject *swig_obj[1] ;
15284
15285 if (!args) SWIG_fail;
15286 swig_obj[0] = args;
15287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15288 if (!SWIG_IsOK(res1)) {
15289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15290 }
15291 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15292 {
15293 PyThreadState* __tstate = wxPyBeginAllowThreads();
15294 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15295 wxPyEndAllowThreads(__tstate);
15296 if (PyErr_Occurred()) SWIG_fail;
15297 }
15298 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15299 return resultobj;
15300 fail:
15301 return NULL;
15302 }
15303
15304
15305 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15306 PyObject *resultobj = 0;
15307 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15308 int result;
15309 void *argp1 = 0 ;
15310 int res1 = 0 ;
15311 PyObject *swig_obj[1] ;
15312
15313 if (!args) SWIG_fail;
15314 swig_obj[0] = args;
15315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15316 if (!SWIG_IsOK(res1)) {
15317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15318 }
15319 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15320 {
15321 PyThreadState* __tstate = wxPyBeginAllowThreads();
15322 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15323 wxPyEndAllowThreads(__tstate);
15324 if (PyErr_Occurred()) SWIG_fail;
15325 }
15326 resultobj = SWIG_From_int(static_cast< int >(result));
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15334 PyObject *resultobj = 0;
15335 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15336 int result;
15337 void *argp1 = 0 ;
15338 int res1 = 0 ;
15339 PyObject *swig_obj[1] ;
15340
15341 if (!args) SWIG_fail;
15342 swig_obj[0] = args;
15343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15344 if (!SWIG_IsOK(res1)) {
15345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15346 }
15347 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15348 {
15349 PyThreadState* __tstate = wxPyBeginAllowThreads();
15350 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15351 wxPyEndAllowThreads(__tstate);
15352 if (PyErr_Occurred()) SWIG_fail;
15353 }
15354 resultobj = SWIG_From_int(static_cast< int >(result));
15355 return resultobj;
15356 fail:
15357 return NULL;
15358 }
15359
15360
15361 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15362 PyObject *resultobj = 0;
15363 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15364 int result;
15365 void *argp1 = 0 ;
15366 int res1 = 0 ;
15367 PyObject *swig_obj[1] ;
15368
15369 if (!args) SWIG_fail;
15370 swig_obj[0] = args;
15371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15372 if (!SWIG_IsOK(res1)) {
15373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15374 }
15375 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15376 {
15377 PyThreadState* __tstate = wxPyBeginAllowThreads();
15378 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15379 wxPyEndAllowThreads(__tstate);
15380 if (PyErr_Occurred()) SWIG_fail;
15381 }
15382 resultobj = SWIG_From_int(static_cast< int >(result));
15383 return resultobj;
15384 fail:
15385 return NULL;
15386 }
15387
15388
15389 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15390 PyObject *resultobj = 0;
15391 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15392 int result;
15393 void *argp1 = 0 ;
15394 int res1 = 0 ;
15395 PyObject *swig_obj[1] ;
15396
15397 if (!args) SWIG_fail;
15398 swig_obj[0] = args;
15399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15400 if (!SWIG_IsOK(res1)) {
15401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15402 }
15403 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15404 {
15405 PyThreadState* __tstate = wxPyBeginAllowThreads();
15406 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 resultobj = SWIG_From_int(static_cast< int >(result));
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj = 0;
15419 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15420 int arg2 ;
15421 void *argp1 = 0 ;
15422 int res1 = 0 ;
15423 int val2 ;
15424 int ecode2 = 0 ;
15425 PyObject * obj0 = 0 ;
15426 PyObject * obj1 = 0 ;
15427 char * kwnames[] = {
15428 (char *) "self",(char *) "stick", NULL
15429 };
15430
15431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15433 if (!SWIG_IsOK(res1)) {
15434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15435 }
15436 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15437 ecode2 = SWIG_AsVal_int(obj1, &val2);
15438 if (!SWIG_IsOK(ecode2)) {
15439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15440 }
15441 arg2 = static_cast< int >(val2);
15442 {
15443 PyThreadState* __tstate = wxPyBeginAllowThreads();
15444 (arg1)->SetJoystick(arg2);
15445 wxPyEndAllowThreads(__tstate);
15446 if (PyErr_Occurred()) SWIG_fail;
15447 }
15448 resultobj = SWIG_Py_Void();
15449 return resultobj;
15450 fail:
15451 return NULL;
15452 }
15453
15454
15455 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15456 PyObject *resultobj = 0;
15457 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15458 int arg2 ;
15459 void *argp1 = 0 ;
15460 int res1 = 0 ;
15461 int val2 ;
15462 int ecode2 = 0 ;
15463 PyObject * obj0 = 0 ;
15464 PyObject * obj1 = 0 ;
15465 char * kwnames[] = {
15466 (char *) "self",(char *) "state", NULL
15467 };
15468
15469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15471 if (!SWIG_IsOK(res1)) {
15472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15473 }
15474 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15475 ecode2 = SWIG_AsVal_int(obj1, &val2);
15476 if (!SWIG_IsOK(ecode2)) {
15477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15478 }
15479 arg2 = static_cast< int >(val2);
15480 {
15481 PyThreadState* __tstate = wxPyBeginAllowThreads();
15482 (arg1)->SetButtonState(arg2);
15483 wxPyEndAllowThreads(__tstate);
15484 if (PyErr_Occurred()) SWIG_fail;
15485 }
15486 resultobj = SWIG_Py_Void();
15487 return resultobj;
15488 fail:
15489 return NULL;
15490 }
15491
15492
15493 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15494 PyObject *resultobj = 0;
15495 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15496 int arg2 ;
15497 void *argp1 = 0 ;
15498 int res1 = 0 ;
15499 int val2 ;
15500 int ecode2 = 0 ;
15501 PyObject * obj0 = 0 ;
15502 PyObject * obj1 = 0 ;
15503 char * kwnames[] = {
15504 (char *) "self",(char *) "change", NULL
15505 };
15506
15507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15509 if (!SWIG_IsOK(res1)) {
15510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15511 }
15512 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15513 ecode2 = SWIG_AsVal_int(obj1, &val2);
15514 if (!SWIG_IsOK(ecode2)) {
15515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15516 }
15517 arg2 = static_cast< int >(val2);
15518 {
15519 PyThreadState* __tstate = wxPyBeginAllowThreads();
15520 (arg1)->SetButtonChange(arg2);
15521 wxPyEndAllowThreads(__tstate);
15522 if (PyErr_Occurred()) SWIG_fail;
15523 }
15524 resultobj = SWIG_Py_Void();
15525 return resultobj;
15526 fail:
15527 return NULL;
15528 }
15529
15530
15531 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15532 PyObject *resultobj = 0;
15533 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15534 wxPoint *arg2 = 0 ;
15535 void *argp1 = 0 ;
15536 int res1 = 0 ;
15537 wxPoint temp2 ;
15538 PyObject * obj0 = 0 ;
15539 PyObject * obj1 = 0 ;
15540 char * kwnames[] = {
15541 (char *) "self",(char *) "pos", NULL
15542 };
15543
15544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15546 if (!SWIG_IsOK(res1)) {
15547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15548 }
15549 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15550 {
15551 arg2 = &temp2;
15552 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15553 }
15554 {
15555 PyThreadState* __tstate = wxPyBeginAllowThreads();
15556 (arg1)->SetPosition((wxPoint const &)*arg2);
15557 wxPyEndAllowThreads(__tstate);
15558 if (PyErr_Occurred()) SWIG_fail;
15559 }
15560 resultobj = SWIG_Py_Void();
15561 return resultobj;
15562 fail:
15563 return NULL;
15564 }
15565
15566
15567 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15568 PyObject *resultobj = 0;
15569 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15570 int arg2 ;
15571 void *argp1 = 0 ;
15572 int res1 = 0 ;
15573 int val2 ;
15574 int ecode2 = 0 ;
15575 PyObject * obj0 = 0 ;
15576 PyObject * obj1 = 0 ;
15577 char * kwnames[] = {
15578 (char *) "self",(char *) "zPos", NULL
15579 };
15580
15581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15583 if (!SWIG_IsOK(res1)) {
15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15585 }
15586 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15587 ecode2 = SWIG_AsVal_int(obj1, &val2);
15588 if (!SWIG_IsOK(ecode2)) {
15589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15590 }
15591 arg2 = static_cast< int >(val2);
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 (arg1)->SetZPosition(arg2);
15595 wxPyEndAllowThreads(__tstate);
15596 if (PyErr_Occurred()) SWIG_fail;
15597 }
15598 resultobj = SWIG_Py_Void();
15599 return resultobj;
15600 fail:
15601 return NULL;
15602 }
15603
15604
15605 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15606 PyObject *resultobj = 0;
15607 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15608 bool result;
15609 void *argp1 = 0 ;
15610 int res1 = 0 ;
15611 PyObject *swig_obj[1] ;
15612
15613 if (!args) SWIG_fail;
15614 swig_obj[0] = args;
15615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15618 }
15619 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15620 {
15621 PyThreadState* __tstate = wxPyBeginAllowThreads();
15622 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 {
15627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15628 }
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15636 PyObject *resultobj = 0;
15637 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15638 bool result;
15639 void *argp1 = 0 ;
15640 int res1 = 0 ;
15641 PyObject *swig_obj[1] ;
15642
15643 if (!args) SWIG_fail;
15644 swig_obj[0] = args;
15645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15646 if (!SWIG_IsOK(res1)) {
15647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15648 }
15649 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 {
15657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15658 }
15659 return resultobj;
15660 fail:
15661 return NULL;
15662 }
15663
15664
15665 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15666 PyObject *resultobj = 0;
15667 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15668 bool result;
15669 void *argp1 = 0 ;
15670 int res1 = 0 ;
15671 PyObject *swig_obj[1] ;
15672
15673 if (!args) SWIG_fail;
15674 swig_obj[0] = args;
15675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15676 if (!SWIG_IsOK(res1)) {
15677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15678 }
15679 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15683 wxPyEndAllowThreads(__tstate);
15684 if (PyErr_Occurred()) SWIG_fail;
15685 }
15686 {
15687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15688 }
15689 return resultobj;
15690 fail:
15691 return NULL;
15692 }
15693
15694
15695 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15696 PyObject *resultobj = 0;
15697 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15698 int arg2 = (int) wxJOY_BUTTON_ANY ;
15699 bool result;
15700 void *argp1 = 0 ;
15701 int res1 = 0 ;
15702 int val2 ;
15703 int ecode2 = 0 ;
15704 PyObject * obj0 = 0 ;
15705 PyObject * obj1 = 0 ;
15706 char * kwnames[] = {
15707 (char *) "self",(char *) "but", NULL
15708 };
15709
15710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15712 if (!SWIG_IsOK(res1)) {
15713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15714 }
15715 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15716 if (obj1) {
15717 ecode2 = SWIG_AsVal_int(obj1, &val2);
15718 if (!SWIG_IsOK(ecode2)) {
15719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15720 }
15721 arg2 = static_cast< int >(val2);
15722 }
15723 {
15724 PyThreadState* __tstate = wxPyBeginAllowThreads();
15725 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15726 wxPyEndAllowThreads(__tstate);
15727 if (PyErr_Occurred()) SWIG_fail;
15728 }
15729 {
15730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15731 }
15732 return resultobj;
15733 fail:
15734 return NULL;
15735 }
15736
15737
15738 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15739 PyObject *resultobj = 0;
15740 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15741 int arg2 = (int) wxJOY_BUTTON_ANY ;
15742 bool result;
15743 void *argp1 = 0 ;
15744 int res1 = 0 ;
15745 int val2 ;
15746 int ecode2 = 0 ;
15747 PyObject * obj0 = 0 ;
15748 PyObject * obj1 = 0 ;
15749 char * kwnames[] = {
15750 (char *) "self",(char *) "but", NULL
15751 };
15752
15753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15755 if (!SWIG_IsOK(res1)) {
15756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15757 }
15758 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15759 if (obj1) {
15760 ecode2 = SWIG_AsVal_int(obj1, &val2);
15761 if (!SWIG_IsOK(ecode2)) {
15762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15763 }
15764 arg2 = static_cast< int >(val2);
15765 }
15766 {
15767 PyThreadState* __tstate = wxPyBeginAllowThreads();
15768 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15769 wxPyEndAllowThreads(__tstate);
15770 if (PyErr_Occurred()) SWIG_fail;
15771 }
15772 {
15773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15774 }
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15782 PyObject *resultobj = 0;
15783 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15784 int arg2 = (int) wxJOY_BUTTON_ANY ;
15785 bool result;
15786 void *argp1 = 0 ;
15787 int res1 = 0 ;
15788 int val2 ;
15789 int ecode2 = 0 ;
15790 PyObject * obj0 = 0 ;
15791 PyObject * obj1 = 0 ;
15792 char * kwnames[] = {
15793 (char *) "self",(char *) "but", NULL
15794 };
15795
15796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15798 if (!SWIG_IsOK(res1)) {
15799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15800 }
15801 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15802 if (obj1) {
15803 ecode2 = SWIG_AsVal_int(obj1, &val2);
15804 if (!SWIG_IsOK(ecode2)) {
15805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15806 }
15807 arg2 = static_cast< int >(val2);
15808 }
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 {
15816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15817 }
15818 return resultobj;
15819 fail:
15820 return NULL;
15821 }
15822
15823
15824 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15825 PyObject *obj;
15826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15827 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15828 return SWIG_Py_Void();
15829 }
15830
15831 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15832 return SWIG_Python_InitShadowInstance(args);
15833 }
15834
15835 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15836 PyObject *resultobj = 0;
15837 wxString const &arg1_defvalue = wxPyEmptyString ;
15838 wxString *arg1 = (wxString *) &arg1_defvalue ;
15839 wxSound *result = 0 ;
15840 bool temp1 = false ;
15841 PyObject * obj0 = 0 ;
15842 char * kwnames[] = {
15843 (char *) "fileName", NULL
15844 };
15845
15846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15847 if (obj0) {
15848 {
15849 arg1 = wxString_in_helper(obj0);
15850 if (arg1 == NULL) SWIG_fail;
15851 temp1 = true;
15852 }
15853 }
15854 {
15855 if (!wxPyCheckForApp()) SWIG_fail;
15856 PyThreadState* __tstate = wxPyBeginAllowThreads();
15857 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15858 wxPyEndAllowThreads(__tstate);
15859 if (PyErr_Occurred()) SWIG_fail;
15860 }
15861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15862 {
15863 if (temp1)
15864 delete arg1;
15865 }
15866 return resultobj;
15867 fail:
15868 {
15869 if (temp1)
15870 delete arg1;
15871 }
15872 return NULL;
15873 }
15874
15875
15876 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15877 PyObject *resultobj = 0;
15878 PyObject *arg1 = (PyObject *) 0 ;
15879 wxSound *result = 0 ;
15880 PyObject * obj0 = 0 ;
15881 char * kwnames[] = {
15882 (char *) "data", NULL
15883 };
15884
15885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15886 arg1 = obj0;
15887 {
15888 if (!wxPyCheckForApp()) SWIG_fail;
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 result = (wxSound *)new_wxSound(arg1);
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15895 return resultobj;
15896 fail:
15897 return NULL;
15898 }
15899
15900
15901 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15902 PyObject *resultobj = 0;
15903 wxSound *arg1 = (wxSound *) 0 ;
15904 void *argp1 = 0 ;
15905 int res1 = 0 ;
15906 PyObject *swig_obj[1] ;
15907
15908 if (!args) SWIG_fail;
15909 swig_obj[0] = args;
15910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15911 if (!SWIG_IsOK(res1)) {
15912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15913 }
15914 arg1 = reinterpret_cast< wxSound * >(argp1);
15915 {
15916 PyThreadState* __tstate = wxPyBeginAllowThreads();
15917 delete arg1;
15918
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 resultobj = SWIG_Py_Void();
15923 return resultobj;
15924 fail:
15925 return NULL;
15926 }
15927
15928
15929 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15930 PyObject *resultobj = 0;
15931 wxSound *arg1 = (wxSound *) 0 ;
15932 wxString *arg2 = 0 ;
15933 bool result;
15934 void *argp1 = 0 ;
15935 int res1 = 0 ;
15936 bool temp2 = false ;
15937 PyObject * obj0 = 0 ;
15938 PyObject * obj1 = 0 ;
15939 char * kwnames[] = {
15940 (char *) "self",(char *) "fileName", NULL
15941 };
15942
15943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15945 if (!SWIG_IsOK(res1)) {
15946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15947 }
15948 arg1 = reinterpret_cast< wxSound * >(argp1);
15949 {
15950 arg2 = wxString_in_helper(obj1);
15951 if (arg2 == NULL) SWIG_fail;
15952 temp2 = true;
15953 }
15954 {
15955 PyThreadState* __tstate = wxPyBeginAllowThreads();
15956 result = (bool)(arg1)->Create((wxString const &)*arg2);
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 {
15961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15962 }
15963 {
15964 if (temp2)
15965 delete arg2;
15966 }
15967 return resultobj;
15968 fail:
15969 {
15970 if (temp2)
15971 delete arg2;
15972 }
15973 return NULL;
15974 }
15975
15976
15977 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15978 PyObject *resultobj = 0;
15979 wxSound *arg1 = (wxSound *) 0 ;
15980 PyObject *arg2 = (PyObject *) 0 ;
15981 bool result;
15982 void *argp1 = 0 ;
15983 int res1 = 0 ;
15984 PyObject * obj0 = 0 ;
15985 PyObject * obj1 = 0 ;
15986 char * kwnames[] = {
15987 (char *) "self",(char *) "data", NULL
15988 };
15989
15990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15994 }
15995 arg1 = reinterpret_cast< wxSound * >(argp1);
15996 arg2 = obj1;
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 result = (bool)wxSound_CreateFromData(arg1,arg2);
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 {
16004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16005 }
16006 return resultobj;
16007 fail:
16008 return NULL;
16009 }
16010
16011
16012 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16013 PyObject *resultobj = 0;
16014 wxSound *arg1 = (wxSound *) 0 ;
16015 bool result;
16016 void *argp1 = 0 ;
16017 int res1 = 0 ;
16018 PyObject *swig_obj[1] ;
16019
16020 if (!args) SWIG_fail;
16021 swig_obj[0] = args;
16022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16023 if (!SWIG_IsOK(res1)) {
16024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16025 }
16026 arg1 = reinterpret_cast< wxSound * >(argp1);
16027 {
16028 PyThreadState* __tstate = wxPyBeginAllowThreads();
16029 result = (bool)(arg1)->IsOk();
16030 wxPyEndAllowThreads(__tstate);
16031 if (PyErr_Occurred()) SWIG_fail;
16032 }
16033 {
16034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16035 }
16036 return resultobj;
16037 fail:
16038 return NULL;
16039 }
16040
16041
16042 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16043 PyObject *resultobj = 0;
16044 wxSound *arg1 = (wxSound *) 0 ;
16045 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16046 bool result;
16047 void *argp1 = 0 ;
16048 int res1 = 0 ;
16049 unsigned int val2 ;
16050 int ecode2 = 0 ;
16051 PyObject * obj0 = 0 ;
16052 PyObject * obj1 = 0 ;
16053 char * kwnames[] = {
16054 (char *) "self",(char *) "flags", NULL
16055 };
16056
16057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16059 if (!SWIG_IsOK(res1)) {
16060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16061 }
16062 arg1 = reinterpret_cast< wxSound * >(argp1);
16063 if (obj1) {
16064 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16065 if (!SWIG_IsOK(ecode2)) {
16066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16067 }
16068 arg2 = static_cast< unsigned int >(val2);
16069 }
16070 {
16071 if (!wxPyCheckForApp()) SWIG_fail;
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = (bool)((wxSound const *)arg1)->Play(arg2);
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 {
16078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16079 }
16080 return resultobj;
16081 fail:
16082 return NULL;
16083 }
16084
16085
16086 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16087 PyObject *resultobj = 0;
16088 wxString *arg1 = 0 ;
16089 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16090 bool result;
16091 bool temp1 = false ;
16092 unsigned int val2 ;
16093 int ecode2 = 0 ;
16094 PyObject * obj0 = 0 ;
16095 PyObject * obj1 = 0 ;
16096 char * kwnames[] = {
16097 (char *) "filename",(char *) "flags", NULL
16098 };
16099
16100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16101 {
16102 arg1 = wxString_in_helper(obj0);
16103 if (arg1 == NULL) SWIG_fail;
16104 temp1 = true;
16105 }
16106 if (obj1) {
16107 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16108 if (!SWIG_IsOK(ecode2)) {
16109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16110 }
16111 arg2 = static_cast< unsigned int >(val2);
16112 }
16113 {
16114 if (!wxPyCheckForApp()) SWIG_fail;
16115 PyThreadState* __tstate = wxPyBeginAllowThreads();
16116 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16117 wxPyEndAllowThreads(__tstate);
16118 if (PyErr_Occurred()) SWIG_fail;
16119 }
16120 {
16121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16122 }
16123 {
16124 if (temp1)
16125 delete arg1;
16126 }
16127 return resultobj;
16128 fail:
16129 {
16130 if (temp1)
16131 delete arg1;
16132 }
16133 return NULL;
16134 }
16135
16136
16137 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16138 PyObject *resultobj = 0;
16139
16140 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16141 {
16142 if (!wxPyCheckForApp()) SWIG_fail;
16143 PyThreadState* __tstate = wxPyBeginAllowThreads();
16144 wxSound::Stop();
16145 wxPyEndAllowThreads(__tstate);
16146 if (PyErr_Occurred()) SWIG_fail;
16147 }
16148 resultobj = SWIG_Py_Void();
16149 return resultobj;
16150 fail:
16151 return NULL;
16152 }
16153
16154
16155 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16156 PyObject *obj;
16157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16158 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16159 return SWIG_Py_Void();
16160 }
16161
16162 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16163 return SWIG_Python_InitShadowInstance(args);
16164 }
16165
16166 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16167 PyObject *resultobj = 0;
16168 wxString *arg1 = 0 ;
16169 wxString *arg2 = 0 ;
16170 wxString *arg3 = 0 ;
16171 wxString *arg4 = 0 ;
16172 wxFileTypeInfo *result = 0 ;
16173 bool temp1 = false ;
16174 bool temp2 = false ;
16175 bool temp3 = false ;
16176 bool temp4 = false ;
16177 PyObject * obj0 = 0 ;
16178 PyObject * obj1 = 0 ;
16179 PyObject * obj2 = 0 ;
16180 PyObject * obj3 = 0 ;
16181 char * kwnames[] = {
16182 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16183 };
16184
16185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16186 {
16187 arg1 = wxString_in_helper(obj0);
16188 if (arg1 == NULL) SWIG_fail;
16189 temp1 = true;
16190 }
16191 {
16192 arg2 = wxString_in_helper(obj1);
16193 if (arg2 == NULL) SWIG_fail;
16194 temp2 = true;
16195 }
16196 {
16197 arg3 = wxString_in_helper(obj2);
16198 if (arg3 == NULL) SWIG_fail;
16199 temp3 = true;
16200 }
16201 {
16202 arg4 = wxString_in_helper(obj3);
16203 if (arg4 == NULL) SWIG_fail;
16204 temp4 = true;
16205 }
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16213 {
16214 if (temp1)
16215 delete arg1;
16216 }
16217 {
16218 if (temp2)
16219 delete arg2;
16220 }
16221 {
16222 if (temp3)
16223 delete arg3;
16224 }
16225 {
16226 if (temp4)
16227 delete arg4;
16228 }
16229 return resultobj;
16230 fail:
16231 {
16232 if (temp1)
16233 delete arg1;
16234 }
16235 {
16236 if (temp2)
16237 delete arg2;
16238 }
16239 {
16240 if (temp3)
16241 delete arg3;
16242 }
16243 {
16244 if (temp4)
16245 delete arg4;
16246 }
16247 return NULL;
16248 }
16249
16250
16251 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16252 PyObject *resultobj = 0;
16253 wxArrayString *arg1 = 0 ;
16254 wxFileTypeInfo *result = 0 ;
16255 bool temp1 = false ;
16256 PyObject * obj0 = 0 ;
16257 char * kwnames[] = {
16258 (char *) "sArray", NULL
16259 };
16260
16261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16262 {
16263 if (! PySequence_Check(obj0)) {
16264 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16265 SWIG_fail;
16266 }
16267 arg1 = new wxArrayString;
16268 temp1 = true;
16269 int i, len=PySequence_Length(obj0);
16270 for (i=0; i<len; i++) {
16271 PyObject* item = PySequence_GetItem(obj0, i);
16272 wxString* s = wxString_in_helper(item);
16273 if (PyErr_Occurred()) SWIG_fail;
16274 arg1->Add(*s);
16275 delete s;
16276 Py_DECREF(item);
16277 }
16278 }
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16282 wxPyEndAllowThreads(__tstate);
16283 if (PyErr_Occurred()) SWIG_fail;
16284 }
16285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16286 {
16287 if (temp1) delete arg1;
16288 }
16289 return resultobj;
16290 fail:
16291 {
16292 if (temp1) delete arg1;
16293 }
16294 return NULL;
16295 }
16296
16297
16298 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16299 PyObject *resultobj = 0;
16300 wxFileTypeInfo *result = 0 ;
16301
16302 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16310 return resultobj;
16311 fail:
16312 return NULL;
16313 }
16314
16315
16316 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16317 PyObject *resultobj = 0;
16318 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16319 bool result;
16320 void *argp1 = 0 ;
16321 int res1 = 0 ;
16322 PyObject *swig_obj[1] ;
16323
16324 if (!args) SWIG_fail;
16325 swig_obj[0] = args;
16326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16327 if (!SWIG_IsOK(res1)) {
16328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16329 }
16330 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16331 {
16332 PyThreadState* __tstate = wxPyBeginAllowThreads();
16333 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16334 wxPyEndAllowThreads(__tstate);
16335 if (PyErr_Occurred()) SWIG_fail;
16336 }
16337 {
16338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16339 }
16340 return resultobj;
16341 fail:
16342 return NULL;
16343 }
16344
16345
16346 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16347 PyObject *resultobj = 0;
16348 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16349 wxString *arg2 = 0 ;
16350 int arg3 = (int) 0 ;
16351 void *argp1 = 0 ;
16352 int res1 = 0 ;
16353 bool temp2 = false ;
16354 int val3 ;
16355 int ecode3 = 0 ;
16356 PyObject * obj0 = 0 ;
16357 PyObject * obj1 = 0 ;
16358 PyObject * obj2 = 0 ;
16359 char * kwnames[] = {
16360 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16361 };
16362
16363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16365 if (!SWIG_IsOK(res1)) {
16366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16367 }
16368 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16369 {
16370 arg2 = wxString_in_helper(obj1);
16371 if (arg2 == NULL) SWIG_fail;
16372 temp2 = true;
16373 }
16374 if (obj2) {
16375 ecode3 = SWIG_AsVal_int(obj2, &val3);
16376 if (!SWIG_IsOK(ecode3)) {
16377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16378 }
16379 arg3 = static_cast< int >(val3);
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 resultobj = SWIG_Py_Void();
16388 {
16389 if (temp2)
16390 delete arg2;
16391 }
16392 return resultobj;
16393 fail:
16394 {
16395 if (temp2)
16396 delete arg2;
16397 }
16398 return NULL;
16399 }
16400
16401
16402 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16403 PyObject *resultobj = 0;
16404 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16405 wxString *arg2 = 0 ;
16406 void *argp1 = 0 ;
16407 int res1 = 0 ;
16408 bool temp2 = false ;
16409 PyObject * obj0 = 0 ;
16410 PyObject * obj1 = 0 ;
16411 char * kwnames[] = {
16412 (char *) "self",(char *) "shortDesc", NULL
16413 };
16414
16415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16417 if (!SWIG_IsOK(res1)) {
16418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16419 }
16420 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16421 {
16422 arg2 = wxString_in_helper(obj1);
16423 if (arg2 == NULL) SWIG_fail;
16424 temp2 = true;
16425 }
16426 {
16427 PyThreadState* __tstate = wxPyBeginAllowThreads();
16428 (arg1)->SetShortDesc((wxString const &)*arg2);
16429 wxPyEndAllowThreads(__tstate);
16430 if (PyErr_Occurred()) SWIG_fail;
16431 }
16432 resultobj = SWIG_Py_Void();
16433 {
16434 if (temp2)
16435 delete arg2;
16436 }
16437 return resultobj;
16438 fail:
16439 {
16440 if (temp2)
16441 delete arg2;
16442 }
16443 return NULL;
16444 }
16445
16446
16447 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16448 PyObject *resultobj = 0;
16449 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16450 wxString *result = 0 ;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 PyObject *swig_obj[1] ;
16454
16455 if (!args) SWIG_fail;
16456 swig_obj[0] = args;
16457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16458 if (!SWIG_IsOK(res1)) {
16459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16460 }
16461 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16462 {
16463 PyThreadState* __tstate = wxPyBeginAllowThreads();
16464 {
16465 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16466 result = (wxString *) &_result_ref;
16467 }
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 {
16472 #if wxUSE_UNICODE
16473 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16474 #else
16475 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16476 #endif
16477 }
16478 return resultobj;
16479 fail:
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16485 PyObject *resultobj = 0;
16486 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16487 wxString *result = 0 ;
16488 void *argp1 = 0 ;
16489 int res1 = 0 ;
16490 PyObject *swig_obj[1] ;
16491
16492 if (!args) SWIG_fail;
16493 swig_obj[0] = args;
16494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16495 if (!SWIG_IsOK(res1)) {
16496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16497 }
16498 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 {
16502 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16503 result = (wxString *) &_result_ref;
16504 }
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 {
16509 #if wxUSE_UNICODE
16510 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16511 #else
16512 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16513 #endif
16514 }
16515 return resultobj;
16516 fail:
16517 return NULL;
16518 }
16519
16520
16521 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16522 PyObject *resultobj = 0;
16523 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16524 wxString *result = 0 ;
16525 void *argp1 = 0 ;
16526 int res1 = 0 ;
16527 PyObject *swig_obj[1] ;
16528
16529 if (!args) SWIG_fail;
16530 swig_obj[0] = args;
16531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16532 if (!SWIG_IsOK(res1)) {
16533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16534 }
16535 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16536 {
16537 PyThreadState* __tstate = wxPyBeginAllowThreads();
16538 {
16539 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16540 result = (wxString *) &_result_ref;
16541 }
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 {
16546 #if wxUSE_UNICODE
16547 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16548 #else
16549 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16550 #endif
16551 }
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16559 PyObject *resultobj = 0;
16560 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16561 wxString *result = 0 ;
16562 void *argp1 = 0 ;
16563 int res1 = 0 ;
16564 PyObject *swig_obj[1] ;
16565
16566 if (!args) SWIG_fail;
16567 swig_obj[0] = args;
16568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16569 if (!SWIG_IsOK(res1)) {
16570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16571 }
16572 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 {
16576 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16577 result = (wxString *) &_result_ref;
16578 }
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 {
16583 #if wxUSE_UNICODE
16584 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16585 #else
16586 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16587 #endif
16588 }
16589 return resultobj;
16590 fail:
16591 return NULL;
16592 }
16593
16594
16595 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16596 PyObject *resultobj = 0;
16597 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16598 wxString *result = 0 ;
16599 void *argp1 = 0 ;
16600 int res1 = 0 ;
16601 PyObject *swig_obj[1] ;
16602
16603 if (!args) SWIG_fail;
16604 swig_obj[0] = args;
16605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16606 if (!SWIG_IsOK(res1)) {
16607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16608 }
16609 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16610 {
16611 PyThreadState* __tstate = wxPyBeginAllowThreads();
16612 {
16613 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16614 result = (wxString *) &_result_ref;
16615 }
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 {
16620 #if wxUSE_UNICODE
16621 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16622 #else
16623 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16624 #endif
16625 }
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16633 PyObject *resultobj = 0;
16634 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16635 wxArrayString *result = 0 ;
16636 void *argp1 = 0 ;
16637 int res1 = 0 ;
16638 PyObject *swig_obj[1] ;
16639
16640 if (!args) SWIG_fail;
16641 swig_obj[0] = args;
16642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16643 if (!SWIG_IsOK(res1)) {
16644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16645 }
16646 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16647 {
16648 PyThreadState* __tstate = wxPyBeginAllowThreads();
16649 {
16650 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16651 result = (wxArrayString *) &_result_ref;
16652 }
16653 wxPyEndAllowThreads(__tstate);
16654 if (PyErr_Occurred()) SWIG_fail;
16655 }
16656 {
16657 resultobj = wxArrayString2PyList_helper(*result);
16658 }
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16666 PyObject *resultobj = 0;
16667 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16668 size_t result;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 PyObject *swig_obj[1] ;
16672
16673 if (!args) SWIG_fail;
16674 swig_obj[0] = args;
16675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16676 if (!SWIG_IsOK(res1)) {
16677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16678 }
16679 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16694 PyObject *resultobj = 0;
16695 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16696 wxString *result = 0 ;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 PyObject *swig_obj[1] ;
16700
16701 if (!args) SWIG_fail;
16702 swig_obj[0] = args;
16703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16704 if (!SWIG_IsOK(res1)) {
16705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16706 }
16707 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 {
16711 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16712 result = (wxString *) &_result_ref;
16713 }
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 {
16718 #if wxUSE_UNICODE
16719 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16720 #else
16721 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16722 #endif
16723 }
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16731 PyObject *resultobj = 0;
16732 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16733 int result;
16734 void *argp1 = 0 ;
16735 int res1 = 0 ;
16736 PyObject *swig_obj[1] ;
16737
16738 if (!args) SWIG_fail;
16739 swig_obj[0] = args;
16740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16741 if (!SWIG_IsOK(res1)) {
16742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16743 }
16744 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16745 {
16746 PyThreadState* __tstate = wxPyBeginAllowThreads();
16747 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16748 wxPyEndAllowThreads(__tstate);
16749 if (PyErr_Occurred()) SWIG_fail;
16750 }
16751 resultobj = SWIG_From_int(static_cast< int >(result));
16752 return resultobj;
16753 fail:
16754 return NULL;
16755 }
16756
16757
16758 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16759 PyObject *obj;
16760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16761 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16762 return SWIG_Py_Void();
16763 }
16764
16765 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16766 return SWIG_Python_InitShadowInstance(args);
16767 }
16768
16769 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16770 PyObject *resultobj = 0;
16771 wxFileTypeInfo *arg1 = 0 ;
16772 wxFileType *result = 0 ;
16773 void *argp1 = 0 ;
16774 int res1 = 0 ;
16775 PyObject * obj0 = 0 ;
16776 char * kwnames[] = {
16777 (char *) "ftInfo", NULL
16778 };
16779
16780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16781 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16782 if (!SWIG_IsOK(res1)) {
16783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16784 }
16785 if (!argp1) {
16786 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16787 }
16788 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16789 {
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16796 return resultobj;
16797 fail:
16798 return NULL;
16799 }
16800
16801
16802 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16803 PyObject *resultobj = 0;
16804 wxFileType *arg1 = (wxFileType *) 0 ;
16805 void *argp1 = 0 ;
16806 int res1 = 0 ;
16807 PyObject *swig_obj[1] ;
16808
16809 if (!args) SWIG_fail;
16810 swig_obj[0] = args;
16811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16812 if (!SWIG_IsOK(res1)) {
16813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16814 }
16815 arg1 = reinterpret_cast< wxFileType * >(argp1);
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 delete arg1;
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 resultobj = SWIG_Py_Void();
16824 return resultobj;
16825 fail:
16826 return NULL;
16827 }
16828
16829
16830 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16831 PyObject *resultobj = 0;
16832 wxFileType *arg1 = (wxFileType *) 0 ;
16833 PyObject *result = 0 ;
16834 void *argp1 = 0 ;
16835 int res1 = 0 ;
16836 PyObject *swig_obj[1] ;
16837
16838 if (!args) SWIG_fail;
16839 swig_obj[0] = args;
16840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16841 if (!SWIG_IsOK(res1)) {
16842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16843 }
16844 arg1 = reinterpret_cast< wxFileType * >(argp1);
16845 {
16846 PyThreadState* __tstate = wxPyBeginAllowThreads();
16847 result = (PyObject *)wxFileType_GetMimeType(arg1);
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 resultobj = result;
16852 return resultobj;
16853 fail:
16854 return NULL;
16855 }
16856
16857
16858 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16859 PyObject *resultobj = 0;
16860 wxFileType *arg1 = (wxFileType *) 0 ;
16861 PyObject *result = 0 ;
16862 void *argp1 = 0 ;
16863 int res1 = 0 ;
16864 PyObject *swig_obj[1] ;
16865
16866 if (!args) SWIG_fail;
16867 swig_obj[0] = args;
16868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16869 if (!SWIG_IsOK(res1)) {
16870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16871 }
16872 arg1 = reinterpret_cast< wxFileType * >(argp1);
16873 {
16874 PyThreadState* __tstate = wxPyBeginAllowThreads();
16875 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16876 wxPyEndAllowThreads(__tstate);
16877 if (PyErr_Occurred()) SWIG_fail;
16878 }
16879 resultobj = result;
16880 return resultobj;
16881 fail:
16882 return NULL;
16883 }
16884
16885
16886 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16887 PyObject *resultobj = 0;
16888 wxFileType *arg1 = (wxFileType *) 0 ;
16889 PyObject *result = 0 ;
16890 void *argp1 = 0 ;
16891 int res1 = 0 ;
16892 PyObject *swig_obj[1] ;
16893
16894 if (!args) SWIG_fail;
16895 swig_obj[0] = args;
16896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16897 if (!SWIG_IsOK(res1)) {
16898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16899 }
16900 arg1 = reinterpret_cast< wxFileType * >(argp1);
16901 {
16902 PyThreadState* __tstate = wxPyBeginAllowThreads();
16903 result = (PyObject *)wxFileType_GetExtensions(arg1);
16904 wxPyEndAllowThreads(__tstate);
16905 if (PyErr_Occurred()) SWIG_fail;
16906 }
16907 resultobj = result;
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16915 PyObject *resultobj = 0;
16916 wxFileType *arg1 = (wxFileType *) 0 ;
16917 wxIcon *result = 0 ;
16918 void *argp1 = 0 ;
16919 int res1 = 0 ;
16920 PyObject *swig_obj[1] ;
16921
16922 if (!args) SWIG_fail;
16923 swig_obj[0] = args;
16924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16925 if (!SWIG_IsOK(res1)) {
16926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16927 }
16928 arg1 = reinterpret_cast< wxFileType * >(argp1);
16929 {
16930 PyThreadState* __tstate = wxPyBeginAllowThreads();
16931 result = (wxIcon *)wxFileType_GetIcon(arg1);
16932 wxPyEndAllowThreads(__tstate);
16933 if (PyErr_Occurred()) SWIG_fail;
16934 }
16935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16936 return resultobj;
16937 fail:
16938 return NULL;
16939 }
16940
16941
16942 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16943 PyObject *resultobj = 0;
16944 wxFileType *arg1 = (wxFileType *) 0 ;
16945 PyObject *result = 0 ;
16946 void *argp1 = 0 ;
16947 int res1 = 0 ;
16948 PyObject *swig_obj[1] ;
16949
16950 if (!args) SWIG_fail;
16951 swig_obj[0] = args;
16952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16953 if (!SWIG_IsOK(res1)) {
16954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16955 }
16956 arg1 = reinterpret_cast< wxFileType * >(argp1);
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 resultobj = result;
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16971 PyObject *resultobj = 0;
16972 wxFileType *arg1 = (wxFileType *) 0 ;
16973 PyObject *result = 0 ;
16974 void *argp1 = 0 ;
16975 int res1 = 0 ;
16976 PyObject *swig_obj[1] ;
16977
16978 if (!args) SWIG_fail;
16979 swig_obj[0] = args;
16980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16981 if (!SWIG_IsOK(res1)) {
16982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16983 }
16984 arg1 = reinterpret_cast< wxFileType * >(argp1);
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (PyObject *)wxFileType_GetDescription(arg1);
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 resultobj = result;
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16999 PyObject *resultobj = 0;
17000 wxFileType *arg1 = (wxFileType *) 0 ;
17001 wxString *arg2 = 0 ;
17002 wxString const &arg3_defvalue = wxPyEmptyString ;
17003 wxString *arg3 = (wxString *) &arg3_defvalue ;
17004 PyObject *result = 0 ;
17005 void *argp1 = 0 ;
17006 int res1 = 0 ;
17007 bool temp2 = false ;
17008 bool temp3 = false ;
17009 PyObject * obj0 = 0 ;
17010 PyObject * obj1 = 0 ;
17011 PyObject * obj2 = 0 ;
17012 char * kwnames[] = {
17013 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17014 };
17015
17016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17018 if (!SWIG_IsOK(res1)) {
17019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17020 }
17021 arg1 = reinterpret_cast< wxFileType * >(argp1);
17022 {
17023 arg2 = wxString_in_helper(obj1);
17024 if (arg2 == NULL) SWIG_fail;
17025 temp2 = true;
17026 }
17027 if (obj2) {
17028 {
17029 arg3 = wxString_in_helper(obj2);
17030 if (arg3 == NULL) SWIG_fail;
17031 temp3 = true;
17032 }
17033 }
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 resultobj = result;
17041 {
17042 if (temp2)
17043 delete arg2;
17044 }
17045 {
17046 if (temp3)
17047 delete arg3;
17048 }
17049 return resultobj;
17050 fail:
17051 {
17052 if (temp2)
17053 delete arg2;
17054 }
17055 {
17056 if (temp3)
17057 delete arg3;
17058 }
17059 return NULL;
17060 }
17061
17062
17063 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17064 PyObject *resultobj = 0;
17065 wxFileType *arg1 = (wxFileType *) 0 ;
17066 wxString *arg2 = 0 ;
17067 wxString const &arg3_defvalue = wxPyEmptyString ;
17068 wxString *arg3 = (wxString *) &arg3_defvalue ;
17069 PyObject *result = 0 ;
17070 void *argp1 = 0 ;
17071 int res1 = 0 ;
17072 bool temp2 = false ;
17073 bool temp3 = false ;
17074 PyObject * obj0 = 0 ;
17075 PyObject * obj1 = 0 ;
17076 PyObject * obj2 = 0 ;
17077 char * kwnames[] = {
17078 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17079 };
17080
17081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17083 if (!SWIG_IsOK(res1)) {
17084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17085 }
17086 arg1 = reinterpret_cast< wxFileType * >(argp1);
17087 {
17088 arg2 = wxString_in_helper(obj1);
17089 if (arg2 == NULL) SWIG_fail;
17090 temp2 = true;
17091 }
17092 if (obj2) {
17093 {
17094 arg3 = wxString_in_helper(obj2);
17095 if (arg3 == NULL) SWIG_fail;
17096 temp3 = true;
17097 }
17098 }
17099 {
17100 PyThreadState* __tstate = wxPyBeginAllowThreads();
17101 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 resultobj = result;
17106 {
17107 if (temp2)
17108 delete arg2;
17109 }
17110 {
17111 if (temp3)
17112 delete arg3;
17113 }
17114 return resultobj;
17115 fail:
17116 {
17117 if (temp2)
17118 delete arg2;
17119 }
17120 {
17121 if (temp3)
17122 delete arg3;
17123 }
17124 return NULL;
17125 }
17126
17127
17128 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17129 PyObject *resultobj = 0;
17130 wxFileType *arg1 = (wxFileType *) 0 ;
17131 wxString *arg2 = 0 ;
17132 wxString const &arg3_defvalue = wxPyEmptyString ;
17133 wxString *arg3 = (wxString *) &arg3_defvalue ;
17134 PyObject *result = 0 ;
17135 void *argp1 = 0 ;
17136 int res1 = 0 ;
17137 bool temp2 = false ;
17138 bool temp3 = false ;
17139 PyObject * obj0 = 0 ;
17140 PyObject * obj1 = 0 ;
17141 PyObject * obj2 = 0 ;
17142 char * kwnames[] = {
17143 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17144 };
17145
17146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17148 if (!SWIG_IsOK(res1)) {
17149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17150 }
17151 arg1 = reinterpret_cast< wxFileType * >(argp1);
17152 {
17153 arg2 = wxString_in_helper(obj1);
17154 if (arg2 == NULL) SWIG_fail;
17155 temp2 = true;
17156 }
17157 if (obj2) {
17158 {
17159 arg3 = wxString_in_helper(obj2);
17160 if (arg3 == NULL) SWIG_fail;
17161 temp3 = true;
17162 }
17163 }
17164 {
17165 PyThreadState* __tstate = wxPyBeginAllowThreads();
17166 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17167 wxPyEndAllowThreads(__tstate);
17168 if (PyErr_Occurred()) SWIG_fail;
17169 }
17170 resultobj = result;
17171 {
17172 if (temp2)
17173 delete arg2;
17174 }
17175 {
17176 if (temp3)
17177 delete arg3;
17178 }
17179 return resultobj;
17180 fail:
17181 {
17182 if (temp2)
17183 delete arg2;
17184 }
17185 {
17186 if (temp3)
17187 delete arg3;
17188 }
17189 return NULL;
17190 }
17191
17192
17193 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj = 0;
17195 wxFileType *arg1 = (wxFileType *) 0 ;
17196 wxString *arg2 = 0 ;
17197 wxString *arg3 = 0 ;
17198 bool arg4 = (bool) true ;
17199 bool result;
17200 void *argp1 = 0 ;
17201 int res1 = 0 ;
17202 bool temp2 = false ;
17203 bool temp3 = false ;
17204 bool val4 ;
17205 int ecode4 = 0 ;
17206 PyObject * obj0 = 0 ;
17207 PyObject * obj1 = 0 ;
17208 PyObject * obj2 = 0 ;
17209 PyObject * obj3 = 0 ;
17210 char * kwnames[] = {
17211 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17212 };
17213
17214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17216 if (!SWIG_IsOK(res1)) {
17217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17218 }
17219 arg1 = reinterpret_cast< wxFileType * >(argp1);
17220 {
17221 arg2 = wxString_in_helper(obj1);
17222 if (arg2 == NULL) SWIG_fail;
17223 temp2 = true;
17224 }
17225 {
17226 arg3 = wxString_in_helper(obj2);
17227 if (arg3 == NULL) SWIG_fail;
17228 temp3 = true;
17229 }
17230 if (obj3) {
17231 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17232 if (!SWIG_IsOK(ecode4)) {
17233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17234 }
17235 arg4 = static_cast< bool >(val4);
17236 }
17237 {
17238 PyThreadState* __tstate = wxPyBeginAllowThreads();
17239 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17240 wxPyEndAllowThreads(__tstate);
17241 if (PyErr_Occurred()) SWIG_fail;
17242 }
17243 {
17244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17245 }
17246 {
17247 if (temp2)
17248 delete arg2;
17249 }
17250 {
17251 if (temp3)
17252 delete arg3;
17253 }
17254 return resultobj;
17255 fail:
17256 {
17257 if (temp2)
17258 delete arg2;
17259 }
17260 {
17261 if (temp3)
17262 delete arg3;
17263 }
17264 return NULL;
17265 }
17266
17267
17268 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17269 PyObject *resultobj = 0;
17270 wxFileType *arg1 = (wxFileType *) 0 ;
17271 wxString const &arg2_defvalue = wxPyEmptyString ;
17272 wxString *arg2 = (wxString *) &arg2_defvalue ;
17273 int arg3 = (int) 0 ;
17274 bool result;
17275 void *argp1 = 0 ;
17276 int res1 = 0 ;
17277 bool temp2 = false ;
17278 int val3 ;
17279 int ecode3 = 0 ;
17280 PyObject * obj0 = 0 ;
17281 PyObject * obj1 = 0 ;
17282 PyObject * obj2 = 0 ;
17283 char * kwnames[] = {
17284 (char *) "self",(char *) "cmd",(char *) "index", NULL
17285 };
17286
17287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17289 if (!SWIG_IsOK(res1)) {
17290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17291 }
17292 arg1 = reinterpret_cast< wxFileType * >(argp1);
17293 if (obj1) {
17294 {
17295 arg2 = wxString_in_helper(obj1);
17296 if (arg2 == NULL) SWIG_fail;
17297 temp2 = true;
17298 }
17299 }
17300 if (obj2) {
17301 ecode3 = SWIG_AsVal_int(obj2, &val3);
17302 if (!SWIG_IsOK(ecode3)) {
17303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17304 }
17305 arg3 = static_cast< int >(val3);
17306 }
17307 {
17308 PyThreadState* __tstate = wxPyBeginAllowThreads();
17309 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17310 wxPyEndAllowThreads(__tstate);
17311 if (PyErr_Occurred()) SWIG_fail;
17312 }
17313 {
17314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17315 }
17316 {
17317 if (temp2)
17318 delete arg2;
17319 }
17320 return resultobj;
17321 fail:
17322 {
17323 if (temp2)
17324 delete arg2;
17325 }
17326 return NULL;
17327 }
17328
17329
17330 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17331 PyObject *resultobj = 0;
17332 wxFileType *arg1 = (wxFileType *) 0 ;
17333 bool result;
17334 void *argp1 = 0 ;
17335 int res1 = 0 ;
17336 PyObject *swig_obj[1] ;
17337
17338 if (!args) SWIG_fail;
17339 swig_obj[0] = args;
17340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17341 if (!SWIG_IsOK(res1)) {
17342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17343 }
17344 arg1 = reinterpret_cast< wxFileType * >(argp1);
17345 {
17346 PyThreadState* __tstate = wxPyBeginAllowThreads();
17347 result = (bool)(arg1)->Unassociate();
17348 wxPyEndAllowThreads(__tstate);
17349 if (PyErr_Occurred()) SWIG_fail;
17350 }
17351 {
17352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17353 }
17354 return resultobj;
17355 fail:
17356 return NULL;
17357 }
17358
17359
17360 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17361 PyObject *resultobj = 0;
17362 wxString *arg1 = 0 ;
17363 wxString *arg2 = 0 ;
17364 wxString const &arg3_defvalue = wxPyEmptyString ;
17365 wxString *arg3 = (wxString *) &arg3_defvalue ;
17366 wxString result;
17367 bool temp1 = false ;
17368 bool temp2 = false ;
17369 bool temp3 = false ;
17370 PyObject * obj0 = 0 ;
17371 PyObject * obj1 = 0 ;
17372 PyObject * obj2 = 0 ;
17373 char * kwnames[] = {
17374 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17375 };
17376
17377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17378 {
17379 arg1 = wxString_in_helper(obj0);
17380 if (arg1 == NULL) SWIG_fail;
17381 temp1 = true;
17382 }
17383 {
17384 arg2 = wxString_in_helper(obj1);
17385 if (arg2 == NULL) SWIG_fail;
17386 temp2 = true;
17387 }
17388 if (obj2) {
17389 {
17390 arg3 = wxString_in_helper(obj2);
17391 if (arg3 == NULL) SWIG_fail;
17392 temp3 = true;
17393 }
17394 }
17395 {
17396 PyThreadState* __tstate = wxPyBeginAllowThreads();
17397 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 {
17402 #if wxUSE_UNICODE
17403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17404 #else
17405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17406 #endif
17407 }
17408 {
17409 if (temp1)
17410 delete arg1;
17411 }
17412 {
17413 if (temp2)
17414 delete arg2;
17415 }
17416 {
17417 if (temp3)
17418 delete arg3;
17419 }
17420 return resultobj;
17421 fail:
17422 {
17423 if (temp1)
17424 delete arg1;
17425 }
17426 {
17427 if (temp2)
17428 delete arg2;
17429 }
17430 {
17431 if (temp3)
17432 delete arg3;
17433 }
17434 return NULL;
17435 }
17436
17437
17438 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 PyObject *obj;
17440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17441 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17442 return SWIG_Py_Void();
17443 }
17444
17445 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17446 return SWIG_Python_InitShadowInstance(args);
17447 }
17448
17449 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17450 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17451 return 1;
17452 }
17453
17454
17455 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17456 PyObject *pyobj = 0;
17457
17458 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17459 return pyobj;
17460 }
17461
17462
17463 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17464 PyObject *resultobj = 0;
17465 wxString *arg1 = 0 ;
17466 wxString *arg2 = 0 ;
17467 bool result;
17468 bool temp1 = false ;
17469 bool temp2 = false ;
17470 PyObject * obj0 = 0 ;
17471 PyObject * obj1 = 0 ;
17472 char * kwnames[] = {
17473 (char *) "mimeType",(char *) "wildcard", NULL
17474 };
17475
17476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17477 {
17478 arg1 = wxString_in_helper(obj0);
17479 if (arg1 == NULL) SWIG_fail;
17480 temp1 = true;
17481 }
17482 {
17483 arg2 = wxString_in_helper(obj1);
17484 if (arg2 == NULL) SWIG_fail;
17485 temp2 = true;
17486 }
17487 {
17488 PyThreadState* __tstate = wxPyBeginAllowThreads();
17489 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17490 wxPyEndAllowThreads(__tstate);
17491 if (PyErr_Occurred()) SWIG_fail;
17492 }
17493 {
17494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17495 }
17496 {
17497 if (temp1)
17498 delete arg1;
17499 }
17500 {
17501 if (temp2)
17502 delete arg2;
17503 }
17504 return resultobj;
17505 fail:
17506 {
17507 if (temp1)
17508 delete arg1;
17509 }
17510 {
17511 if (temp2)
17512 delete arg2;
17513 }
17514 return NULL;
17515 }
17516
17517
17518 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17519 PyObject *resultobj = 0;
17520 wxMimeTypesManager *result = 0 ;
17521
17522 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17523 {
17524 PyThreadState* __tstate = wxPyBeginAllowThreads();
17525 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17526 wxPyEndAllowThreads(__tstate);
17527 if (PyErr_Occurred()) SWIG_fail;
17528 }
17529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17530 return resultobj;
17531 fail:
17532 return NULL;
17533 }
17534
17535
17536 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17537 PyObject *resultobj = 0;
17538 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17539 int arg2 = (int) wxMAILCAP_ALL ;
17540 wxString const &arg3_defvalue = wxPyEmptyString ;
17541 wxString *arg3 = (wxString *) &arg3_defvalue ;
17542 void *argp1 = 0 ;
17543 int res1 = 0 ;
17544 int val2 ;
17545 int ecode2 = 0 ;
17546 bool temp3 = false ;
17547 PyObject * obj0 = 0 ;
17548 PyObject * obj1 = 0 ;
17549 PyObject * obj2 = 0 ;
17550 char * kwnames[] = {
17551 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17552 };
17553
17554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17556 if (!SWIG_IsOK(res1)) {
17557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17558 }
17559 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17560 if (obj1) {
17561 ecode2 = SWIG_AsVal_int(obj1, &val2);
17562 if (!SWIG_IsOK(ecode2)) {
17563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17564 }
17565 arg2 = static_cast< int >(val2);
17566 }
17567 if (obj2) {
17568 {
17569 arg3 = wxString_in_helper(obj2);
17570 if (arg3 == NULL) SWIG_fail;
17571 temp3 = true;
17572 }
17573 }
17574 {
17575 PyThreadState* __tstate = wxPyBeginAllowThreads();
17576 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17577 wxPyEndAllowThreads(__tstate);
17578 if (PyErr_Occurred()) SWIG_fail;
17579 }
17580 resultobj = SWIG_Py_Void();
17581 {
17582 if (temp3)
17583 delete arg3;
17584 }
17585 return resultobj;
17586 fail:
17587 {
17588 if (temp3)
17589 delete arg3;
17590 }
17591 return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 PyObject *resultobj = 0;
17597 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17598 void *argp1 = 0 ;
17599 int res1 = 0 ;
17600 PyObject *swig_obj[1] ;
17601
17602 if (!args) SWIG_fail;
17603 swig_obj[0] = args;
17604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17605 if (!SWIG_IsOK(res1)) {
17606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17607 }
17608 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17609 {
17610 PyThreadState* __tstate = wxPyBeginAllowThreads();
17611 (arg1)->ClearData();
17612 wxPyEndAllowThreads(__tstate);
17613 if (PyErr_Occurred()) SWIG_fail;
17614 }
17615 resultobj = SWIG_Py_Void();
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj = 0;
17624 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17625 wxString *arg2 = 0 ;
17626 wxFileType *result = 0 ;
17627 void *argp1 = 0 ;
17628 int res1 = 0 ;
17629 bool temp2 = false ;
17630 PyObject * obj0 = 0 ;
17631 PyObject * obj1 = 0 ;
17632 char * kwnames[] = {
17633 (char *) "self",(char *) "ext", NULL
17634 };
17635
17636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17638 if (!SWIG_IsOK(res1)) {
17639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17640 }
17641 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17642 {
17643 arg2 = wxString_in_helper(obj1);
17644 if (arg2 == NULL) SWIG_fail;
17645 temp2 = true;
17646 }
17647 {
17648 PyThreadState* __tstate = wxPyBeginAllowThreads();
17649 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17650 wxPyEndAllowThreads(__tstate);
17651 if (PyErr_Occurred()) SWIG_fail;
17652 }
17653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17654 {
17655 if (temp2)
17656 delete arg2;
17657 }
17658 return resultobj;
17659 fail:
17660 {
17661 if (temp2)
17662 delete arg2;
17663 }
17664 return NULL;
17665 }
17666
17667
17668 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17669 PyObject *resultobj = 0;
17670 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17671 wxString *arg2 = 0 ;
17672 wxFileType *result = 0 ;
17673 void *argp1 = 0 ;
17674 int res1 = 0 ;
17675 bool temp2 = false ;
17676 PyObject * obj0 = 0 ;
17677 PyObject * obj1 = 0 ;
17678 char * kwnames[] = {
17679 (char *) "self",(char *) "mimeType", NULL
17680 };
17681
17682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17684 if (!SWIG_IsOK(res1)) {
17685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17686 }
17687 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17688 {
17689 arg2 = wxString_in_helper(obj1);
17690 if (arg2 == NULL) SWIG_fail;
17691 temp2 = true;
17692 }
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17696 wxPyEndAllowThreads(__tstate);
17697 if (PyErr_Occurred()) SWIG_fail;
17698 }
17699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17700 {
17701 if (temp2)
17702 delete arg2;
17703 }
17704 return resultobj;
17705 fail:
17706 {
17707 if (temp2)
17708 delete arg2;
17709 }
17710 return NULL;
17711 }
17712
17713
17714 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj = 0;
17716 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17717 wxString *arg2 = 0 ;
17718 bool arg3 = (bool) false ;
17719 bool result;
17720 void *argp1 = 0 ;
17721 int res1 = 0 ;
17722 bool temp2 = false ;
17723 bool val3 ;
17724 int ecode3 = 0 ;
17725 PyObject * obj0 = 0 ;
17726 PyObject * obj1 = 0 ;
17727 PyObject * obj2 = 0 ;
17728 char * kwnames[] = {
17729 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17730 };
17731
17732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17734 if (!SWIG_IsOK(res1)) {
17735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17736 }
17737 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17738 {
17739 arg2 = wxString_in_helper(obj1);
17740 if (arg2 == NULL) SWIG_fail;
17741 temp2 = true;
17742 }
17743 if (obj2) {
17744 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17745 if (!SWIG_IsOK(ecode3)) {
17746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17747 }
17748 arg3 = static_cast< bool >(val3);
17749 }
17750 {
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 {
17757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17758 }
17759 {
17760 if (temp2)
17761 delete arg2;
17762 }
17763 return resultobj;
17764 fail:
17765 {
17766 if (temp2)
17767 delete arg2;
17768 }
17769 return NULL;
17770 }
17771
17772
17773 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17774 PyObject *resultobj = 0;
17775 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17776 wxString *arg2 = 0 ;
17777 bool result;
17778 void *argp1 = 0 ;
17779 int res1 = 0 ;
17780 bool temp2 = false ;
17781 PyObject * obj0 = 0 ;
17782 PyObject * obj1 = 0 ;
17783 char * kwnames[] = {
17784 (char *) "self",(char *) "filename", NULL
17785 };
17786
17787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17789 if (!SWIG_IsOK(res1)) {
17790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17791 }
17792 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17793 {
17794 arg2 = wxString_in_helper(obj1);
17795 if (arg2 == NULL) SWIG_fail;
17796 temp2 = true;
17797 }
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17801 wxPyEndAllowThreads(__tstate);
17802 if (PyErr_Occurred()) SWIG_fail;
17803 }
17804 {
17805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17806 }
17807 {
17808 if (temp2)
17809 delete arg2;
17810 }
17811 return resultobj;
17812 fail:
17813 {
17814 if (temp2)
17815 delete arg2;
17816 }
17817 return NULL;
17818 }
17819
17820
17821 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17822 PyObject *resultobj = 0;
17823 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17824 PyObject *result = 0 ;
17825 void *argp1 = 0 ;
17826 int res1 = 0 ;
17827 PyObject *swig_obj[1] ;
17828
17829 if (!args) SWIG_fail;
17830 swig_obj[0] = args;
17831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17832 if (!SWIG_IsOK(res1)) {
17833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17834 }
17835 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17836 {
17837 PyThreadState* __tstate = wxPyBeginAllowThreads();
17838 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17839 wxPyEndAllowThreads(__tstate);
17840 if (PyErr_Occurred()) SWIG_fail;
17841 }
17842 resultobj = result;
17843 return resultobj;
17844 fail:
17845 return NULL;
17846 }
17847
17848
17849 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17850 PyObject *resultobj = 0;
17851 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17852 wxFileTypeInfo *arg2 = 0 ;
17853 void *argp1 = 0 ;
17854 int res1 = 0 ;
17855 void *argp2 = 0 ;
17856 int res2 = 0 ;
17857 PyObject * obj0 = 0 ;
17858 PyObject * obj1 = 0 ;
17859 char * kwnames[] = {
17860 (char *) "self",(char *) "ft", NULL
17861 };
17862
17863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17865 if (!SWIG_IsOK(res1)) {
17866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17867 }
17868 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17869 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17870 if (!SWIG_IsOK(res2)) {
17871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17872 }
17873 if (!argp2) {
17874 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17875 }
17876 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17877 {
17878 PyThreadState* __tstate = wxPyBeginAllowThreads();
17879 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17880 wxPyEndAllowThreads(__tstate);
17881 if (PyErr_Occurred()) SWIG_fail;
17882 }
17883 resultobj = SWIG_Py_Void();
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17891 PyObject *resultobj = 0;
17892 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17893 wxFileTypeInfo *arg2 = 0 ;
17894 wxFileType *result = 0 ;
17895 void *argp1 = 0 ;
17896 int res1 = 0 ;
17897 void *argp2 = 0 ;
17898 int res2 = 0 ;
17899 PyObject * obj0 = 0 ;
17900 PyObject * obj1 = 0 ;
17901 char * kwnames[] = {
17902 (char *) "self",(char *) "ftInfo", NULL
17903 };
17904
17905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17907 if (!SWIG_IsOK(res1)) {
17908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17909 }
17910 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17911 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17912 if (!SWIG_IsOK(res2)) {
17913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17914 }
17915 if (!argp2) {
17916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17917 }
17918 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17922 wxPyEndAllowThreads(__tstate);
17923 if (PyErr_Occurred()) SWIG_fail;
17924 }
17925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17933 PyObject *resultobj = 0;
17934 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17935 wxFileType *arg2 = (wxFileType *) 0 ;
17936 bool result;
17937 void *argp1 = 0 ;
17938 int res1 = 0 ;
17939 void *argp2 = 0 ;
17940 int res2 = 0 ;
17941 PyObject * obj0 = 0 ;
17942 PyObject * obj1 = 0 ;
17943 char * kwnames[] = {
17944 (char *) "self",(char *) "ft", NULL
17945 };
17946
17947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17949 if (!SWIG_IsOK(res1)) {
17950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17951 }
17952 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17953 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17954 if (!SWIG_IsOK(res2)) {
17955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17956 }
17957 arg2 = reinterpret_cast< wxFileType * >(argp2);
17958 {
17959 PyThreadState* __tstate = wxPyBeginAllowThreads();
17960 result = (bool)(arg1)->Unassociate(arg2);
17961 wxPyEndAllowThreads(__tstate);
17962 if (PyErr_Occurred()) SWIG_fail;
17963 }
17964 {
17965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17966 }
17967 return resultobj;
17968 fail:
17969 return NULL;
17970 }
17971
17972
17973 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17974 PyObject *resultobj = 0;
17975 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17976 void *argp1 = 0 ;
17977 int res1 = 0 ;
17978 PyObject *swig_obj[1] ;
17979
17980 if (!args) SWIG_fail;
17981 swig_obj[0] = args;
17982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17983 if (!SWIG_IsOK(res1)) {
17984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17985 }
17986 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17987 {
17988 PyThreadState* __tstate = wxPyBeginAllowThreads();
17989 delete arg1;
17990
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 resultobj = SWIG_Py_Void();
17995 return resultobj;
17996 fail:
17997 return NULL;
17998 }
17999
18000
18001 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18002 PyObject *obj;
18003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18004 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18005 return SWIG_Py_Void();
18006 }
18007
18008 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18009 return SWIG_Python_InitShadowInstance(args);
18010 }
18011
18012 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18013 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18014 return 1;
18015 }
18016
18017
18018 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18019 PyObject *pyobj = 0;
18020
18021 {
18022 #if wxUSE_UNICODE
18023 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18024 #else
18025 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18026 #endif
18027 }
18028 return pyobj;
18029 }
18030
18031
18032 SWIGINTERN int ART_MENU_set(PyObject *) {
18033 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18034 return 1;
18035 }
18036
18037
18038 SWIGINTERN PyObject *ART_MENU_get(void) {
18039 PyObject *pyobj = 0;
18040
18041 {
18042 #if wxUSE_UNICODE
18043 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18044 #else
18045 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18046 #endif
18047 }
18048 return pyobj;
18049 }
18050
18051
18052 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18053 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18054 return 1;
18055 }
18056
18057
18058 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18059 PyObject *pyobj = 0;
18060
18061 {
18062 #if wxUSE_UNICODE
18063 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18064 #else
18065 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18066 #endif
18067 }
18068 return pyobj;
18069 }
18070
18071
18072 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18073 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18074 return 1;
18075 }
18076
18077
18078 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18079 PyObject *pyobj = 0;
18080
18081 {
18082 #if wxUSE_UNICODE
18083 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18084 #else
18085 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18086 #endif
18087 }
18088 return pyobj;
18089 }
18090
18091
18092 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18093 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18094 return 1;
18095 }
18096
18097
18098 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18099 PyObject *pyobj = 0;
18100
18101 {
18102 #if wxUSE_UNICODE
18103 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18104 #else
18105 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18106 #endif
18107 }
18108 return pyobj;
18109 }
18110
18111
18112 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18113 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18114 return 1;
18115 }
18116
18117
18118 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18119 PyObject *pyobj = 0;
18120
18121 {
18122 #if wxUSE_UNICODE
18123 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18124 #else
18125 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18126 #endif
18127 }
18128 return pyobj;
18129 }
18130
18131
18132 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18133 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18134 return 1;
18135 }
18136
18137
18138 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18139 PyObject *pyobj = 0;
18140
18141 {
18142 #if wxUSE_UNICODE
18143 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18144 #else
18145 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18146 #endif
18147 }
18148 return pyobj;
18149 }
18150
18151
18152 SWIGINTERN int ART_OTHER_set(PyObject *) {
18153 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18154 return 1;
18155 }
18156
18157
18158 SWIGINTERN PyObject *ART_OTHER_get(void) {
18159 PyObject *pyobj = 0;
18160
18161 {
18162 #if wxUSE_UNICODE
18163 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18164 #else
18165 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18166 #endif
18167 }
18168 return pyobj;
18169 }
18170
18171
18172 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18173 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18174 return 1;
18175 }
18176
18177
18178 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18179 PyObject *pyobj = 0;
18180
18181 {
18182 #if wxUSE_UNICODE
18183 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18184 #else
18185 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18186 #endif
18187 }
18188 return pyobj;
18189 }
18190
18191
18192 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18193 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18194 return 1;
18195 }
18196
18197
18198 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18199 PyObject *pyobj = 0;
18200
18201 {
18202 #if wxUSE_UNICODE
18203 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18204 #else
18205 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18206 #endif
18207 }
18208 return pyobj;
18209 }
18210
18211
18212 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18213 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18214 return 1;
18215 }
18216
18217
18218 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18219 PyObject *pyobj = 0;
18220
18221 {
18222 #if wxUSE_UNICODE
18223 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18224 #else
18225 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18226 #endif
18227 }
18228 return pyobj;
18229 }
18230
18231
18232 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18233 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18234 return 1;
18235 }
18236
18237
18238 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18239 PyObject *pyobj = 0;
18240
18241 {
18242 #if wxUSE_UNICODE
18243 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18244 #else
18245 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18246 #endif
18247 }
18248 return pyobj;
18249 }
18250
18251
18252 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18253 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18254 return 1;
18255 }
18256
18257
18258 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18259 PyObject *pyobj = 0;
18260
18261 {
18262 #if wxUSE_UNICODE
18263 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18264 #else
18265 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18266 #endif
18267 }
18268 return pyobj;
18269 }
18270
18271
18272 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18273 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18274 return 1;
18275 }
18276
18277
18278 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18279 PyObject *pyobj = 0;
18280
18281 {
18282 #if wxUSE_UNICODE
18283 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18284 #else
18285 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18286 #endif
18287 }
18288 return pyobj;
18289 }
18290
18291
18292 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18293 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18294 return 1;
18295 }
18296
18297
18298 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18299 PyObject *pyobj = 0;
18300
18301 {
18302 #if wxUSE_UNICODE
18303 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18304 #else
18305 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18306 #endif
18307 }
18308 return pyobj;
18309 }
18310
18311
18312 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18313 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18314 return 1;
18315 }
18316
18317
18318 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18319 PyObject *pyobj = 0;
18320
18321 {
18322 #if wxUSE_UNICODE
18323 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18324 #else
18325 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18326 #endif
18327 }
18328 return pyobj;
18329 }
18330
18331
18332 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18333 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18334 return 1;
18335 }
18336
18337
18338 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18339 PyObject *pyobj = 0;
18340
18341 {
18342 #if wxUSE_UNICODE
18343 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18344 #else
18345 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18346 #endif
18347 }
18348 return pyobj;
18349 }
18350
18351
18352 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18353 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18354 return 1;
18355 }
18356
18357
18358 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18359 PyObject *pyobj = 0;
18360
18361 {
18362 #if wxUSE_UNICODE
18363 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18364 #else
18365 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18366 #endif
18367 }
18368 return pyobj;
18369 }
18370
18371
18372 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18373 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18374 return 1;
18375 }
18376
18377
18378 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18379 PyObject *pyobj = 0;
18380
18381 {
18382 #if wxUSE_UNICODE
18383 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18384 #else
18385 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18386 #endif
18387 }
18388 return pyobj;
18389 }
18390
18391
18392 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18393 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18394 return 1;
18395 }
18396
18397
18398 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18399 PyObject *pyobj = 0;
18400
18401 {
18402 #if wxUSE_UNICODE
18403 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18404 #else
18405 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18406 #endif
18407 }
18408 return pyobj;
18409 }
18410
18411
18412 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18413 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18414 return 1;
18415 }
18416
18417
18418 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18419 PyObject *pyobj = 0;
18420
18421 {
18422 #if wxUSE_UNICODE
18423 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18424 #else
18425 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18426 #endif
18427 }
18428 return pyobj;
18429 }
18430
18431
18432 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18433 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18434 return 1;
18435 }
18436
18437
18438 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18439 PyObject *pyobj = 0;
18440
18441 {
18442 #if wxUSE_UNICODE
18443 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18444 #else
18445 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18446 #endif
18447 }
18448 return pyobj;
18449 }
18450
18451
18452 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18453 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18454 return 1;
18455 }
18456
18457
18458 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18459 PyObject *pyobj = 0;
18460
18461 {
18462 #if wxUSE_UNICODE
18463 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18464 #else
18465 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18466 #endif
18467 }
18468 return pyobj;
18469 }
18470
18471
18472 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18473 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18474 return 1;
18475 }
18476
18477
18478 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18479 PyObject *pyobj = 0;
18480
18481 {
18482 #if wxUSE_UNICODE
18483 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18484 #else
18485 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18486 #endif
18487 }
18488 return pyobj;
18489 }
18490
18491
18492 SWIGINTERN int ART_PRINT_set(PyObject *) {
18493 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18494 return 1;
18495 }
18496
18497
18498 SWIGINTERN PyObject *ART_PRINT_get(void) {
18499 PyObject *pyobj = 0;
18500
18501 {
18502 #if wxUSE_UNICODE
18503 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18504 #else
18505 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18506 #endif
18507 }
18508 return pyobj;
18509 }
18510
18511
18512 SWIGINTERN int ART_HELP_set(PyObject *) {
18513 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18514 return 1;
18515 }
18516
18517
18518 SWIGINTERN PyObject *ART_HELP_get(void) {
18519 PyObject *pyobj = 0;
18520
18521 {
18522 #if wxUSE_UNICODE
18523 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18524 #else
18525 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18526 #endif
18527 }
18528 return pyobj;
18529 }
18530
18531
18532 SWIGINTERN int ART_TIP_set(PyObject *) {
18533 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18534 return 1;
18535 }
18536
18537
18538 SWIGINTERN PyObject *ART_TIP_get(void) {
18539 PyObject *pyobj = 0;
18540
18541 {
18542 #if wxUSE_UNICODE
18543 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18544 #else
18545 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18546 #endif
18547 }
18548 return pyobj;
18549 }
18550
18551
18552 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18553 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18554 return 1;
18555 }
18556
18557
18558 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18559 PyObject *pyobj = 0;
18560
18561 {
18562 #if wxUSE_UNICODE
18563 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18564 #else
18565 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18566 #endif
18567 }
18568 return pyobj;
18569 }
18570
18571
18572 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18573 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18574 return 1;
18575 }
18576
18577
18578 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18579 PyObject *pyobj = 0;
18580
18581 {
18582 #if wxUSE_UNICODE
18583 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18584 #else
18585 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18586 #endif
18587 }
18588 return pyobj;
18589 }
18590
18591
18592 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18593 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18594 return 1;
18595 }
18596
18597
18598 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18599 PyObject *pyobj = 0;
18600
18601 {
18602 #if wxUSE_UNICODE
18603 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18604 #else
18605 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18606 #endif
18607 }
18608 return pyobj;
18609 }
18610
18611
18612 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18613 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18614 return 1;
18615 }
18616
18617
18618 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18619 PyObject *pyobj = 0;
18620
18621 {
18622 #if wxUSE_UNICODE
18623 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18624 #else
18625 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18626 #endif
18627 }
18628 return pyobj;
18629 }
18630
18631
18632 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18633 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18634 return 1;
18635 }
18636
18637
18638 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18639 PyObject *pyobj = 0;
18640
18641 {
18642 #if wxUSE_UNICODE
18643 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18644 #else
18645 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18646 #endif
18647 }
18648 return pyobj;
18649 }
18650
18651
18652 SWIGINTERN int ART_CDROM_set(PyObject *) {
18653 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18654 return 1;
18655 }
18656
18657
18658 SWIGINTERN PyObject *ART_CDROM_get(void) {
18659 PyObject *pyobj = 0;
18660
18661 {
18662 #if wxUSE_UNICODE
18663 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18664 #else
18665 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18666 #endif
18667 }
18668 return pyobj;
18669 }
18670
18671
18672 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18673 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18674 return 1;
18675 }
18676
18677
18678 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18679 PyObject *pyobj = 0;
18680
18681 {
18682 #if wxUSE_UNICODE
18683 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18684 #else
18685 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18686 #endif
18687 }
18688 return pyobj;
18689 }
18690
18691
18692 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18693 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18694 return 1;
18695 }
18696
18697
18698 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18699 PyObject *pyobj = 0;
18700
18701 {
18702 #if wxUSE_UNICODE
18703 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18704 #else
18705 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18706 #endif
18707 }
18708 return pyobj;
18709 }
18710
18711
18712 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18713 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18714 return 1;
18715 }
18716
18717
18718 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18719 PyObject *pyobj = 0;
18720
18721 {
18722 #if wxUSE_UNICODE
18723 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18724 #else
18725 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18726 #endif
18727 }
18728 return pyobj;
18729 }
18730
18731
18732 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18733 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18734 return 1;
18735 }
18736
18737
18738 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18739 PyObject *pyobj = 0;
18740
18741 {
18742 #if wxUSE_UNICODE
18743 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18744 #else
18745 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18746 #endif
18747 }
18748 return pyobj;
18749 }
18750
18751
18752 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18753 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18754 return 1;
18755 }
18756
18757
18758 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18759 PyObject *pyobj = 0;
18760
18761 {
18762 #if wxUSE_UNICODE
18763 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18764 #else
18765 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18766 #endif
18767 }
18768 return pyobj;
18769 }
18770
18771
18772 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18773 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18774 return 1;
18775 }
18776
18777
18778 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18779 PyObject *pyobj = 0;
18780
18781 {
18782 #if wxUSE_UNICODE
18783 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18784 #else
18785 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18786 #endif
18787 }
18788 return pyobj;
18789 }
18790
18791
18792 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18793 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18794 return 1;
18795 }
18796
18797
18798 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18799 PyObject *pyobj = 0;
18800
18801 {
18802 #if wxUSE_UNICODE
18803 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18804 #else
18805 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18806 #endif
18807 }
18808 return pyobj;
18809 }
18810
18811
18812 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18813 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18814 return 1;
18815 }
18816
18817
18818 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18819 PyObject *pyobj = 0;
18820
18821 {
18822 #if wxUSE_UNICODE
18823 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18824 #else
18825 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18826 #endif
18827 }
18828 return pyobj;
18829 }
18830
18831
18832 SWIGINTERN int ART_ERROR_set(PyObject *) {
18833 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18834 return 1;
18835 }
18836
18837
18838 SWIGINTERN PyObject *ART_ERROR_get(void) {
18839 PyObject *pyobj = 0;
18840
18841 {
18842 #if wxUSE_UNICODE
18843 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18844 #else
18845 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18846 #endif
18847 }
18848 return pyobj;
18849 }
18850
18851
18852 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18853 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18854 return 1;
18855 }
18856
18857
18858 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18859 PyObject *pyobj = 0;
18860
18861 {
18862 #if wxUSE_UNICODE
18863 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18864 #else
18865 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18866 #endif
18867 }
18868 return pyobj;
18869 }
18870
18871
18872 SWIGINTERN int ART_WARNING_set(PyObject *) {
18873 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18874 return 1;
18875 }
18876
18877
18878 SWIGINTERN PyObject *ART_WARNING_get(void) {
18879 PyObject *pyobj = 0;
18880
18881 {
18882 #if wxUSE_UNICODE
18883 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18884 #else
18885 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18886 #endif
18887 }
18888 return pyobj;
18889 }
18890
18891
18892 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18893 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18894 return 1;
18895 }
18896
18897
18898 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18899 PyObject *pyobj = 0;
18900
18901 {
18902 #if wxUSE_UNICODE
18903 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18904 #else
18905 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18906 #endif
18907 }
18908 return pyobj;
18909 }
18910
18911
18912 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18913 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18914 return 1;
18915 }
18916
18917
18918 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18919 PyObject *pyobj = 0;
18920
18921 {
18922 #if wxUSE_UNICODE
18923 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18924 #else
18925 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18926 #endif
18927 }
18928 return pyobj;
18929 }
18930
18931
18932 SWIGINTERN int ART_COPY_set(PyObject *) {
18933 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18934 return 1;
18935 }
18936
18937
18938 SWIGINTERN PyObject *ART_COPY_get(void) {
18939 PyObject *pyobj = 0;
18940
18941 {
18942 #if wxUSE_UNICODE
18943 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18944 #else
18945 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18946 #endif
18947 }
18948 return pyobj;
18949 }
18950
18951
18952 SWIGINTERN int ART_CUT_set(PyObject *) {
18953 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18954 return 1;
18955 }
18956
18957
18958 SWIGINTERN PyObject *ART_CUT_get(void) {
18959 PyObject *pyobj = 0;
18960
18961 {
18962 #if wxUSE_UNICODE
18963 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18964 #else
18965 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18966 #endif
18967 }
18968 return pyobj;
18969 }
18970
18971
18972 SWIGINTERN int ART_PASTE_set(PyObject *) {
18973 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18974 return 1;
18975 }
18976
18977
18978 SWIGINTERN PyObject *ART_PASTE_get(void) {
18979 PyObject *pyobj = 0;
18980
18981 {
18982 #if wxUSE_UNICODE
18983 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18984 #else
18985 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18986 #endif
18987 }
18988 return pyobj;
18989 }
18990
18991
18992 SWIGINTERN int ART_DELETE_set(PyObject *) {
18993 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18994 return 1;
18995 }
18996
18997
18998 SWIGINTERN PyObject *ART_DELETE_get(void) {
18999 PyObject *pyobj = 0;
19000
19001 {
19002 #if wxUSE_UNICODE
19003 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19004 #else
19005 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19006 #endif
19007 }
19008 return pyobj;
19009 }
19010
19011
19012 SWIGINTERN int ART_NEW_set(PyObject *) {
19013 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19014 return 1;
19015 }
19016
19017
19018 SWIGINTERN PyObject *ART_NEW_get(void) {
19019 PyObject *pyobj = 0;
19020
19021 {
19022 #if wxUSE_UNICODE
19023 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19024 #else
19025 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19026 #endif
19027 }
19028 return pyobj;
19029 }
19030
19031
19032 SWIGINTERN int ART_UNDO_set(PyObject *) {
19033 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19034 return 1;
19035 }
19036
19037
19038 SWIGINTERN PyObject *ART_UNDO_get(void) {
19039 PyObject *pyobj = 0;
19040
19041 {
19042 #if wxUSE_UNICODE
19043 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19044 #else
19045 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19046 #endif
19047 }
19048 return pyobj;
19049 }
19050
19051
19052 SWIGINTERN int ART_REDO_set(PyObject *) {
19053 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19054 return 1;
19055 }
19056
19057
19058 SWIGINTERN PyObject *ART_REDO_get(void) {
19059 PyObject *pyobj = 0;
19060
19061 {
19062 #if wxUSE_UNICODE
19063 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19064 #else
19065 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19066 #endif
19067 }
19068 return pyobj;
19069 }
19070
19071
19072 SWIGINTERN int ART_QUIT_set(PyObject *) {
19073 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19074 return 1;
19075 }
19076
19077
19078 SWIGINTERN PyObject *ART_QUIT_get(void) {
19079 PyObject *pyobj = 0;
19080
19081 {
19082 #if wxUSE_UNICODE
19083 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19084 #else
19085 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19086 #endif
19087 }
19088 return pyobj;
19089 }
19090
19091
19092 SWIGINTERN int ART_FIND_set(PyObject *) {
19093 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19094 return 1;
19095 }
19096
19097
19098 SWIGINTERN PyObject *ART_FIND_get(void) {
19099 PyObject *pyobj = 0;
19100
19101 {
19102 #if wxUSE_UNICODE
19103 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19104 #else
19105 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19106 #endif
19107 }
19108 return pyobj;
19109 }
19110
19111
19112 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19113 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19114 return 1;
19115 }
19116
19117
19118 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19119 PyObject *pyobj = 0;
19120
19121 {
19122 #if wxUSE_UNICODE
19123 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19124 #else
19125 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19126 #endif
19127 }
19128 return pyobj;
19129 }
19130
19131
19132 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19133 PyObject *resultobj = 0;
19134 wxPyArtProvider *result = 0 ;
19135
19136 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19137 {
19138 if (!wxPyCheckForApp()) SWIG_fail;
19139 PyThreadState* __tstate = wxPyBeginAllowThreads();
19140 result = (wxPyArtProvider *)new wxPyArtProvider();
19141 wxPyEndAllowThreads(__tstate);
19142 if (PyErr_Occurred()) SWIG_fail;
19143 }
19144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19145 return resultobj;
19146 fail:
19147 return NULL;
19148 }
19149
19150
19151 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19152 PyObject *resultobj = 0;
19153 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19154 void *argp1 = 0 ;
19155 int res1 = 0 ;
19156 PyObject *swig_obj[1] ;
19157
19158 if (!args) SWIG_fail;
19159 swig_obj[0] = args;
19160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19161 if (!SWIG_IsOK(res1)) {
19162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19163 }
19164 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 delete arg1;
19168
19169 wxPyEndAllowThreads(__tstate);
19170 if (PyErr_Occurred()) SWIG_fail;
19171 }
19172 resultobj = SWIG_Py_Void();
19173 return resultobj;
19174 fail:
19175 return NULL;
19176 }
19177
19178
19179 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19180 PyObject *resultobj = 0;
19181 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19182 PyObject *arg2 = (PyObject *) 0 ;
19183 PyObject *arg3 = (PyObject *) 0 ;
19184 void *argp1 = 0 ;
19185 int res1 = 0 ;
19186 PyObject * obj0 = 0 ;
19187 PyObject * obj1 = 0 ;
19188 PyObject * obj2 = 0 ;
19189 char * kwnames[] = {
19190 (char *) "self",(char *) "self",(char *) "_class", NULL
19191 };
19192
19193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19195 if (!SWIG_IsOK(res1)) {
19196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19197 }
19198 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19199 arg2 = obj1;
19200 arg3 = obj2;
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 (arg1)->_setCallbackInfo(arg2,arg3);
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 resultobj = SWIG_Py_Void();
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19215 PyObject *resultobj = 0;
19216 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19217 int res1 = 0 ;
19218 PyObject * obj0 = 0 ;
19219 char * kwnames[] = {
19220 (char *) "provider", NULL
19221 };
19222
19223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19224 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19225 if (!SWIG_IsOK(res1)) {
19226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19227 }
19228 {
19229 PyThreadState* __tstate = wxPyBeginAllowThreads();
19230 wxPyArtProvider::PushProvider(arg1);
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_Py_Void();
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19242 PyObject *resultobj = 0;
19243 bool result;
19244
19245 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19246 {
19247 PyThreadState* __tstate = wxPyBeginAllowThreads();
19248 result = (bool)wxPyArtProvider::PopProvider();
19249 wxPyEndAllowThreads(__tstate);
19250 if (PyErr_Occurred()) SWIG_fail;
19251 }
19252 {
19253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19254 }
19255 return resultobj;
19256 fail:
19257 return NULL;
19258 }
19259
19260
19261 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19262 PyObject *resultobj = 0;
19263 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19264 bool result;
19265 void *argp1 = 0 ;
19266 int res1 = 0 ;
19267 PyObject * obj0 = 0 ;
19268 char * kwnames[] = {
19269 (char *) "provider", NULL
19270 };
19271
19272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19276 }
19277 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19278 {
19279 PyThreadState* __tstate = wxPyBeginAllowThreads();
19280 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19281 wxPyEndAllowThreads(__tstate);
19282 if (PyErr_Occurred()) SWIG_fail;
19283 }
19284 {
19285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19286 }
19287 return resultobj;
19288 fail:
19289 return NULL;
19290 }
19291
19292
19293 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19294 PyObject *resultobj = 0;
19295 wxString *arg1 = 0 ;
19296 wxString const &arg2_defvalue = wxPyART_OTHER ;
19297 wxString *arg2 = (wxString *) &arg2_defvalue ;
19298 wxSize const &arg3_defvalue = wxDefaultSize ;
19299 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19300 wxBitmap result;
19301 bool temp1 = false ;
19302 bool temp2 = false ;
19303 wxSize temp3 ;
19304 PyObject * obj0 = 0 ;
19305 PyObject * obj1 = 0 ;
19306 PyObject * obj2 = 0 ;
19307 char * kwnames[] = {
19308 (char *) "id",(char *) "client",(char *) "size", NULL
19309 };
19310
19311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19312 {
19313 arg1 = wxString_in_helper(obj0);
19314 if (arg1 == NULL) SWIG_fail;
19315 temp1 = true;
19316 }
19317 if (obj1) {
19318 {
19319 arg2 = wxString_in_helper(obj1);
19320 if (arg2 == NULL) SWIG_fail;
19321 temp2 = true;
19322 }
19323 }
19324 if (obj2) {
19325 {
19326 arg3 = &temp3;
19327 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19328 }
19329 }
19330 {
19331 if (!wxPyCheckForApp()) SWIG_fail;
19332 PyThreadState* __tstate = wxPyBeginAllowThreads();
19333 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19334 wxPyEndAllowThreads(__tstate);
19335 if (PyErr_Occurred()) SWIG_fail;
19336 }
19337 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19338 {
19339 if (temp1)
19340 delete arg1;
19341 }
19342 {
19343 if (temp2)
19344 delete arg2;
19345 }
19346 return resultobj;
19347 fail:
19348 {
19349 if (temp1)
19350 delete arg1;
19351 }
19352 {
19353 if (temp2)
19354 delete arg2;
19355 }
19356 return NULL;
19357 }
19358
19359
19360 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19361 PyObject *resultobj = 0;
19362 wxString *arg1 = 0 ;
19363 wxString const &arg2_defvalue = wxPyART_OTHER ;
19364 wxString *arg2 = (wxString *) &arg2_defvalue ;
19365 wxSize const &arg3_defvalue = wxDefaultSize ;
19366 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19367 wxIcon result;
19368 bool temp1 = false ;
19369 bool temp2 = false ;
19370 wxSize temp3 ;
19371 PyObject * obj0 = 0 ;
19372 PyObject * obj1 = 0 ;
19373 PyObject * obj2 = 0 ;
19374 char * kwnames[] = {
19375 (char *) "id",(char *) "client",(char *) "size", NULL
19376 };
19377
19378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19379 {
19380 arg1 = wxString_in_helper(obj0);
19381 if (arg1 == NULL) SWIG_fail;
19382 temp1 = true;
19383 }
19384 if (obj1) {
19385 {
19386 arg2 = wxString_in_helper(obj1);
19387 if (arg2 == NULL) SWIG_fail;
19388 temp2 = true;
19389 }
19390 }
19391 if (obj2) {
19392 {
19393 arg3 = &temp3;
19394 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19395 }
19396 }
19397 {
19398 if (!wxPyCheckForApp()) SWIG_fail;
19399 PyThreadState* __tstate = wxPyBeginAllowThreads();
19400 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19401 wxPyEndAllowThreads(__tstate);
19402 if (PyErr_Occurred()) SWIG_fail;
19403 }
19404 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19405 {
19406 if (temp1)
19407 delete arg1;
19408 }
19409 {
19410 if (temp2)
19411 delete arg2;
19412 }
19413 return resultobj;
19414 fail:
19415 {
19416 if (temp1)
19417 delete arg1;
19418 }
19419 {
19420 if (temp2)
19421 delete arg2;
19422 }
19423 return NULL;
19424 }
19425
19426
19427 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19428 PyObject *resultobj = 0;
19429 wxString *arg1 = 0 ;
19430 bool arg2 = (bool) false ;
19431 wxSize result;
19432 bool temp1 = false ;
19433 bool val2 ;
19434 int ecode2 = 0 ;
19435 PyObject * obj0 = 0 ;
19436 PyObject * obj1 = 0 ;
19437 char * kwnames[] = {
19438 (char *) "client",(char *) "platform_dependent", NULL
19439 };
19440
19441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19442 {
19443 arg1 = wxString_in_helper(obj0);
19444 if (arg1 == NULL) SWIG_fail;
19445 temp1 = true;
19446 }
19447 if (obj1) {
19448 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19449 if (!SWIG_IsOK(ecode2)) {
19450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19451 }
19452 arg2 = static_cast< bool >(val2);
19453 }
19454 {
19455 PyThreadState* __tstate = wxPyBeginAllowThreads();
19456 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19457 wxPyEndAllowThreads(__tstate);
19458 if (PyErr_Occurred()) SWIG_fail;
19459 }
19460 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19461 {
19462 if (temp1)
19463 delete arg1;
19464 }
19465 return resultobj;
19466 fail:
19467 {
19468 if (temp1)
19469 delete arg1;
19470 }
19471 return NULL;
19472 }
19473
19474
19475 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19476 PyObject *resultobj = 0;
19477 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19478 void *argp1 = 0 ;
19479 int res1 = 0 ;
19480 PyObject *swig_obj[1] ;
19481
19482 if (!args) SWIG_fail;
19483 swig_obj[0] = args;
19484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19485 if (!SWIG_IsOK(res1)) {
19486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19487 }
19488 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 wxPyArtProvider_Destroy(arg1);
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 resultobj = SWIG_Py_Void();
19496 return resultobj;
19497 fail:
19498 return NULL;
19499 }
19500
19501
19502 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19503 PyObject *obj;
19504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19505 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19506 return SWIG_Py_Void();
19507 }
19508
19509 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19510 return SWIG_Python_InitShadowInstance(args);
19511 }
19512
19513 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19514 PyObject *resultobj = 0;
19515 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19516 void *argp1 = 0 ;
19517 int res1 = 0 ;
19518 PyObject *swig_obj[1] ;
19519
19520 if (!args) SWIG_fail;
19521 swig_obj[0] = args;
19522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19523 if (!SWIG_IsOK(res1)) {
19524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19525 }
19526 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19527 {
19528 PyThreadState* __tstate = wxPyBeginAllowThreads();
19529 delete arg1;
19530
19531 wxPyEndAllowThreads(__tstate);
19532 if (PyErr_Occurred()) SWIG_fail;
19533 }
19534 resultobj = SWIG_Py_Void();
19535 return resultobj;
19536 fail:
19537 return NULL;
19538 }
19539
19540
19541 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19542 PyObject *resultobj = 0;
19543 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19544 wxConfigBase *result = 0 ;
19545 int res1 = 0 ;
19546 PyObject * obj0 = 0 ;
19547 char * kwnames[] = {
19548 (char *) "config", NULL
19549 };
19550
19551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19552 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19553 if (!SWIG_IsOK(res1)) {
19554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19555 }
19556 {
19557 PyThreadState* __tstate = wxPyBeginAllowThreads();
19558 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19559 wxPyEndAllowThreads(__tstate);
19560 if (PyErr_Occurred()) SWIG_fail;
19561 }
19562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19563 return resultobj;
19564 fail:
19565 return NULL;
19566 }
19567
19568
19569 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19570 PyObject *resultobj = 0;
19571 bool arg1 = (bool) true ;
19572 wxConfigBase *result = 0 ;
19573 bool val1 ;
19574 int ecode1 = 0 ;
19575 PyObject * obj0 = 0 ;
19576 char * kwnames[] = {
19577 (char *) "createOnDemand", NULL
19578 };
19579
19580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19581 if (obj0) {
19582 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19583 if (!SWIG_IsOK(ecode1)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19585 }
19586 arg1 = static_cast< bool >(val1);
19587 }
19588 {
19589 PyThreadState* __tstate = wxPyBeginAllowThreads();
19590 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19591 wxPyEndAllowThreads(__tstate);
19592 if (PyErr_Occurred()) SWIG_fail;
19593 }
19594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19595 return resultobj;
19596 fail:
19597 return NULL;
19598 }
19599
19600
19601 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19602 PyObject *resultobj = 0;
19603 wxConfigBase *result = 0 ;
19604
19605 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19606 {
19607 PyThreadState* __tstate = wxPyBeginAllowThreads();
19608 result = (wxConfigBase *)wxConfigBase::Create();
19609 wxPyEndAllowThreads(__tstate);
19610 if (PyErr_Occurred()) SWIG_fail;
19611 }
19612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19613 return resultobj;
19614 fail:
19615 return NULL;
19616 }
19617
19618
19619 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19620 PyObject *resultobj = 0;
19621
19622 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19623 {
19624 PyThreadState* __tstate = wxPyBeginAllowThreads();
19625 wxConfigBase::DontCreateOnDemand();
19626 wxPyEndAllowThreads(__tstate);
19627 if (PyErr_Occurred()) SWIG_fail;
19628 }
19629 resultobj = SWIG_Py_Void();
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj = 0;
19638 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19639 wxString *arg2 = 0 ;
19640 void *argp1 = 0 ;
19641 int res1 = 0 ;
19642 bool temp2 = false ;
19643 PyObject * obj0 = 0 ;
19644 PyObject * obj1 = 0 ;
19645 char * kwnames[] = {
19646 (char *) "self",(char *) "path", NULL
19647 };
19648
19649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19651 if (!SWIG_IsOK(res1)) {
19652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19653 }
19654 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19655 {
19656 arg2 = wxString_in_helper(obj1);
19657 if (arg2 == NULL) SWIG_fail;
19658 temp2 = true;
19659 }
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 (arg1)->SetPath((wxString const &)*arg2);
19663 wxPyEndAllowThreads(__tstate);
19664 if (PyErr_Occurred()) SWIG_fail;
19665 }
19666 resultobj = SWIG_Py_Void();
19667 {
19668 if (temp2)
19669 delete arg2;
19670 }
19671 return resultobj;
19672 fail:
19673 {
19674 if (temp2)
19675 delete arg2;
19676 }
19677 return NULL;
19678 }
19679
19680
19681 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19682 PyObject *resultobj = 0;
19683 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19684 wxString *result = 0 ;
19685 void *argp1 = 0 ;
19686 int res1 = 0 ;
19687 PyObject *swig_obj[1] ;
19688
19689 if (!args) SWIG_fail;
19690 swig_obj[0] = args;
19691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19692 if (!SWIG_IsOK(res1)) {
19693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19694 }
19695 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19696 {
19697 PyThreadState* __tstate = wxPyBeginAllowThreads();
19698 {
19699 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19700 result = (wxString *) &_result_ref;
19701 }
19702 wxPyEndAllowThreads(__tstate);
19703 if (PyErr_Occurred()) SWIG_fail;
19704 }
19705 {
19706 #if wxUSE_UNICODE
19707 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19708 #else
19709 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19710 #endif
19711 }
19712 return resultobj;
19713 fail:
19714 return NULL;
19715 }
19716
19717
19718 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19719 PyObject *resultobj = 0;
19720 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19721 PyObject *result = 0 ;
19722 void *argp1 = 0 ;
19723 int res1 = 0 ;
19724 PyObject *swig_obj[1] ;
19725
19726 if (!args) SWIG_fail;
19727 swig_obj[0] = args;
19728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19729 if (!SWIG_IsOK(res1)) {
19730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19731 }
19732 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19733 {
19734 PyThreadState* __tstate = wxPyBeginAllowThreads();
19735 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19736 wxPyEndAllowThreads(__tstate);
19737 if (PyErr_Occurred()) SWIG_fail;
19738 }
19739 resultobj = result;
19740 return resultobj;
19741 fail:
19742 return NULL;
19743 }
19744
19745
19746 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19747 PyObject *resultobj = 0;
19748 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19749 long arg2 ;
19750 PyObject *result = 0 ;
19751 void *argp1 = 0 ;
19752 int res1 = 0 ;
19753 long val2 ;
19754 int ecode2 = 0 ;
19755 PyObject * obj0 = 0 ;
19756 PyObject * obj1 = 0 ;
19757 char * kwnames[] = {
19758 (char *) "self",(char *) "index", NULL
19759 };
19760
19761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19763 if (!SWIG_IsOK(res1)) {
19764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19765 }
19766 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19767 ecode2 = SWIG_AsVal_long(obj1, &val2);
19768 if (!SWIG_IsOK(ecode2)) {
19769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19770 }
19771 arg2 = static_cast< long >(val2);
19772 {
19773 PyThreadState* __tstate = wxPyBeginAllowThreads();
19774 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19775 wxPyEndAllowThreads(__tstate);
19776 if (PyErr_Occurred()) SWIG_fail;
19777 }
19778 resultobj = result;
19779 return resultobj;
19780 fail:
19781 return NULL;
19782 }
19783
19784
19785 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19786 PyObject *resultobj = 0;
19787 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19788 PyObject *result = 0 ;
19789 void *argp1 = 0 ;
19790 int res1 = 0 ;
19791 PyObject *swig_obj[1] ;
19792
19793 if (!args) SWIG_fail;
19794 swig_obj[0] = args;
19795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19796 if (!SWIG_IsOK(res1)) {
19797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19798 }
19799 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 resultobj = result;
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19814 PyObject *resultobj = 0;
19815 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19816 long arg2 ;
19817 PyObject *result = 0 ;
19818 void *argp1 = 0 ;
19819 int res1 = 0 ;
19820 long val2 ;
19821 int ecode2 = 0 ;
19822 PyObject * obj0 = 0 ;
19823 PyObject * obj1 = 0 ;
19824 char * kwnames[] = {
19825 (char *) "self",(char *) "index", NULL
19826 };
19827
19828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19830 if (!SWIG_IsOK(res1)) {
19831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19832 }
19833 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19834 ecode2 = SWIG_AsVal_long(obj1, &val2);
19835 if (!SWIG_IsOK(ecode2)) {
19836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19837 }
19838 arg2 = static_cast< long >(val2);
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19842 wxPyEndAllowThreads(__tstate);
19843 if (PyErr_Occurred()) SWIG_fail;
19844 }
19845 resultobj = result;
19846 return resultobj;
19847 fail:
19848 return NULL;
19849 }
19850
19851
19852 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19853 PyObject *resultobj = 0;
19854 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19855 bool arg2 = (bool) false ;
19856 size_t result;
19857 void *argp1 = 0 ;
19858 int res1 = 0 ;
19859 bool val2 ;
19860 int ecode2 = 0 ;
19861 PyObject * obj0 = 0 ;
19862 PyObject * obj1 = 0 ;
19863 char * kwnames[] = {
19864 (char *) "self",(char *) "recursive", NULL
19865 };
19866
19867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19869 if (!SWIG_IsOK(res1)) {
19870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19871 }
19872 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19873 if (obj1) {
19874 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19875 if (!SWIG_IsOK(ecode2)) {
19876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19877 }
19878 arg2 = static_cast< bool >(val2);
19879 }
19880 {
19881 PyThreadState* __tstate = wxPyBeginAllowThreads();
19882 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19883 wxPyEndAllowThreads(__tstate);
19884 if (PyErr_Occurred()) SWIG_fail;
19885 }
19886 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19887 return resultobj;
19888 fail:
19889 return NULL;
19890 }
19891
19892
19893 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19894 PyObject *resultobj = 0;
19895 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19896 bool arg2 = (bool) false ;
19897 size_t result;
19898 void *argp1 = 0 ;
19899 int res1 = 0 ;
19900 bool val2 ;
19901 int ecode2 = 0 ;
19902 PyObject * obj0 = 0 ;
19903 PyObject * obj1 = 0 ;
19904 char * kwnames[] = {
19905 (char *) "self",(char *) "recursive", NULL
19906 };
19907
19908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19910 if (!SWIG_IsOK(res1)) {
19911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19912 }
19913 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19914 if (obj1) {
19915 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19916 if (!SWIG_IsOK(ecode2)) {
19917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19918 }
19919 arg2 = static_cast< bool >(val2);
19920 }
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19924 wxPyEndAllowThreads(__tstate);
19925 if (PyErr_Occurred()) SWIG_fail;
19926 }
19927 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj = 0;
19936 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19937 wxString *arg2 = 0 ;
19938 bool result;
19939 void *argp1 = 0 ;
19940 int res1 = 0 ;
19941 bool temp2 = false ;
19942 PyObject * obj0 = 0 ;
19943 PyObject * obj1 = 0 ;
19944 char * kwnames[] = {
19945 (char *) "self",(char *) "name", NULL
19946 };
19947
19948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19950 if (!SWIG_IsOK(res1)) {
19951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19952 }
19953 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19954 {
19955 arg2 = wxString_in_helper(obj1);
19956 if (arg2 == NULL) SWIG_fail;
19957 temp2 = true;
19958 }
19959 {
19960 PyThreadState* __tstate = wxPyBeginAllowThreads();
19961 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19962 wxPyEndAllowThreads(__tstate);
19963 if (PyErr_Occurred()) SWIG_fail;
19964 }
19965 {
19966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19967 }
19968 {
19969 if (temp2)
19970 delete arg2;
19971 }
19972 return resultobj;
19973 fail:
19974 {
19975 if (temp2)
19976 delete arg2;
19977 }
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19983 PyObject *resultobj = 0;
19984 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19985 wxString *arg2 = 0 ;
19986 bool result;
19987 void *argp1 = 0 ;
19988 int res1 = 0 ;
19989 bool temp2 = false ;
19990 PyObject * obj0 = 0 ;
19991 PyObject * obj1 = 0 ;
19992 char * kwnames[] = {
19993 (char *) "self",(char *) "name", NULL
19994 };
19995
19996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19998 if (!SWIG_IsOK(res1)) {
19999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20000 }
20001 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20002 {
20003 arg2 = wxString_in_helper(obj1);
20004 if (arg2 == NULL) SWIG_fail;
20005 temp2 = true;
20006 }
20007 {
20008 PyThreadState* __tstate = wxPyBeginAllowThreads();
20009 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 {
20014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20015 }
20016 {
20017 if (temp2)
20018 delete arg2;
20019 }
20020 return resultobj;
20021 fail:
20022 {
20023 if (temp2)
20024 delete arg2;
20025 }
20026 return NULL;
20027 }
20028
20029
20030 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj = 0;
20032 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20033 wxString *arg2 = 0 ;
20034 bool result;
20035 void *argp1 = 0 ;
20036 int res1 = 0 ;
20037 bool temp2 = false ;
20038 PyObject * obj0 = 0 ;
20039 PyObject * obj1 = 0 ;
20040 char * kwnames[] = {
20041 (char *) "self",(char *) "name", NULL
20042 };
20043
20044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20046 if (!SWIG_IsOK(res1)) {
20047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20048 }
20049 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20050 {
20051 arg2 = wxString_in_helper(obj1);
20052 if (arg2 == NULL) SWIG_fail;
20053 temp2 = true;
20054 }
20055 {
20056 PyThreadState* __tstate = wxPyBeginAllowThreads();
20057 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20058 wxPyEndAllowThreads(__tstate);
20059 if (PyErr_Occurred()) SWIG_fail;
20060 }
20061 {
20062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20063 }
20064 {
20065 if (temp2)
20066 delete arg2;
20067 }
20068 return resultobj;
20069 fail:
20070 {
20071 if (temp2)
20072 delete arg2;
20073 }
20074 return NULL;
20075 }
20076
20077
20078 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20079 PyObject *resultobj = 0;
20080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20081 wxString *arg2 = 0 ;
20082 wxConfigBase::EntryType result;
20083 void *argp1 = 0 ;
20084 int res1 = 0 ;
20085 bool temp2 = false ;
20086 PyObject * obj0 = 0 ;
20087 PyObject * obj1 = 0 ;
20088 char * kwnames[] = {
20089 (char *) "self",(char *) "name", NULL
20090 };
20091
20092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20094 if (!SWIG_IsOK(res1)) {
20095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20096 }
20097 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20098 {
20099 arg2 = wxString_in_helper(obj1);
20100 if (arg2 == NULL) SWIG_fail;
20101 temp2 = true;
20102 }
20103 {
20104 PyThreadState* __tstate = wxPyBeginAllowThreads();
20105 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20106 wxPyEndAllowThreads(__tstate);
20107 if (PyErr_Occurred()) SWIG_fail;
20108 }
20109 resultobj = SWIG_From_int(static_cast< int >(result));
20110 {
20111 if (temp2)
20112 delete arg2;
20113 }
20114 return resultobj;
20115 fail:
20116 {
20117 if (temp2)
20118 delete arg2;
20119 }
20120 return NULL;
20121 }
20122
20123
20124 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20125 PyObject *resultobj = 0;
20126 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20127 wxString *arg2 = 0 ;
20128 wxString const &arg3_defvalue = wxPyEmptyString ;
20129 wxString *arg3 = (wxString *) &arg3_defvalue ;
20130 wxString result;
20131 void *argp1 = 0 ;
20132 int res1 = 0 ;
20133 bool temp2 = false ;
20134 bool temp3 = false ;
20135 PyObject * obj0 = 0 ;
20136 PyObject * obj1 = 0 ;
20137 PyObject * obj2 = 0 ;
20138 char * kwnames[] = {
20139 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20140 };
20141
20142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20144 if (!SWIG_IsOK(res1)) {
20145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20146 }
20147 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20148 {
20149 arg2 = wxString_in_helper(obj1);
20150 if (arg2 == NULL) SWIG_fail;
20151 temp2 = true;
20152 }
20153 if (obj2) {
20154 {
20155 arg3 = wxString_in_helper(obj2);
20156 if (arg3 == NULL) SWIG_fail;
20157 temp3 = true;
20158 }
20159 }
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 {
20167 #if wxUSE_UNICODE
20168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20169 #else
20170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20171 #endif
20172 }
20173 {
20174 if (temp2)
20175 delete arg2;
20176 }
20177 {
20178 if (temp3)
20179 delete arg3;
20180 }
20181 return resultobj;
20182 fail:
20183 {
20184 if (temp2)
20185 delete arg2;
20186 }
20187 {
20188 if (temp3)
20189 delete arg3;
20190 }
20191 return NULL;
20192 }
20193
20194
20195 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20196 PyObject *resultobj = 0;
20197 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20198 wxString *arg2 = 0 ;
20199 long arg3 = (long) 0 ;
20200 long result;
20201 void *argp1 = 0 ;
20202 int res1 = 0 ;
20203 bool temp2 = false ;
20204 long val3 ;
20205 int ecode3 = 0 ;
20206 PyObject * obj0 = 0 ;
20207 PyObject * obj1 = 0 ;
20208 PyObject * obj2 = 0 ;
20209 char * kwnames[] = {
20210 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20211 };
20212
20213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20215 if (!SWIG_IsOK(res1)) {
20216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20217 }
20218 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20219 {
20220 arg2 = wxString_in_helper(obj1);
20221 if (arg2 == NULL) SWIG_fail;
20222 temp2 = true;
20223 }
20224 if (obj2) {
20225 ecode3 = SWIG_AsVal_long(obj2, &val3);
20226 if (!SWIG_IsOK(ecode3)) {
20227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20228 }
20229 arg3 = static_cast< long >(val3);
20230 }
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 resultobj = SWIG_From_long(static_cast< long >(result));
20238 {
20239 if (temp2)
20240 delete arg2;
20241 }
20242 return resultobj;
20243 fail:
20244 {
20245 if (temp2)
20246 delete arg2;
20247 }
20248 return NULL;
20249 }
20250
20251
20252 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20253 PyObject *resultobj = 0;
20254 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20255 wxString *arg2 = 0 ;
20256 double arg3 = (double) 0.0 ;
20257 double result;
20258 void *argp1 = 0 ;
20259 int res1 = 0 ;
20260 bool temp2 = false ;
20261 double val3 ;
20262 int ecode3 = 0 ;
20263 PyObject * obj0 = 0 ;
20264 PyObject * obj1 = 0 ;
20265 PyObject * obj2 = 0 ;
20266 char * kwnames[] = {
20267 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20268 };
20269
20270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20272 if (!SWIG_IsOK(res1)) {
20273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20274 }
20275 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20276 {
20277 arg2 = wxString_in_helper(obj1);
20278 if (arg2 == NULL) SWIG_fail;
20279 temp2 = true;
20280 }
20281 if (obj2) {
20282 ecode3 = SWIG_AsVal_double(obj2, &val3);
20283 if (!SWIG_IsOK(ecode3)) {
20284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20285 }
20286 arg3 = static_cast< double >(val3);
20287 }
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 resultobj = SWIG_From_double(static_cast< double >(result));
20295 {
20296 if (temp2)
20297 delete arg2;
20298 }
20299 return resultobj;
20300 fail:
20301 {
20302 if (temp2)
20303 delete arg2;
20304 }
20305 return NULL;
20306 }
20307
20308
20309 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj = 0;
20311 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20312 wxString *arg2 = 0 ;
20313 bool arg3 = (bool) false ;
20314 bool result;
20315 void *argp1 = 0 ;
20316 int res1 = 0 ;
20317 bool temp2 = false ;
20318 bool val3 ;
20319 int ecode3 = 0 ;
20320 PyObject * obj0 = 0 ;
20321 PyObject * obj1 = 0 ;
20322 PyObject * obj2 = 0 ;
20323 char * kwnames[] = {
20324 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20325 };
20326
20327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20329 if (!SWIG_IsOK(res1)) {
20330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20331 }
20332 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20333 {
20334 arg2 = wxString_in_helper(obj1);
20335 if (arg2 == NULL) SWIG_fail;
20336 temp2 = true;
20337 }
20338 if (obj2) {
20339 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20340 if (!SWIG_IsOK(ecode3)) {
20341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20342 }
20343 arg3 = static_cast< bool >(val3);
20344 }
20345 {
20346 PyThreadState* __tstate = wxPyBeginAllowThreads();
20347 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20348 wxPyEndAllowThreads(__tstate);
20349 if (PyErr_Occurred()) SWIG_fail;
20350 }
20351 {
20352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20353 }
20354 {
20355 if (temp2)
20356 delete arg2;
20357 }
20358 return resultobj;
20359 fail:
20360 {
20361 if (temp2)
20362 delete arg2;
20363 }
20364 return NULL;
20365 }
20366
20367
20368 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20369 PyObject *resultobj = 0;
20370 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20371 wxString *arg2 = 0 ;
20372 wxString *arg3 = 0 ;
20373 bool result;
20374 void *argp1 = 0 ;
20375 int res1 = 0 ;
20376 bool temp2 = false ;
20377 bool temp3 = false ;
20378 PyObject * obj0 = 0 ;
20379 PyObject * obj1 = 0 ;
20380 PyObject * obj2 = 0 ;
20381 char * kwnames[] = {
20382 (char *) "self",(char *) "key",(char *) "value", NULL
20383 };
20384
20385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20387 if (!SWIG_IsOK(res1)) {
20388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20389 }
20390 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20391 {
20392 arg2 = wxString_in_helper(obj1);
20393 if (arg2 == NULL) SWIG_fail;
20394 temp2 = true;
20395 }
20396 {
20397 arg3 = wxString_in_helper(obj2);
20398 if (arg3 == NULL) SWIG_fail;
20399 temp3 = true;
20400 }
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 {
20408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20409 }
20410 {
20411 if (temp2)
20412 delete arg2;
20413 }
20414 {
20415 if (temp3)
20416 delete arg3;
20417 }
20418 return resultobj;
20419 fail:
20420 {
20421 if (temp2)
20422 delete arg2;
20423 }
20424 {
20425 if (temp3)
20426 delete arg3;
20427 }
20428 return NULL;
20429 }
20430
20431
20432 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20433 PyObject *resultobj = 0;
20434 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20435 wxString *arg2 = 0 ;
20436 long arg3 ;
20437 bool result;
20438 void *argp1 = 0 ;
20439 int res1 = 0 ;
20440 bool temp2 = false ;
20441 long val3 ;
20442 int ecode3 = 0 ;
20443 PyObject * obj0 = 0 ;
20444 PyObject * obj1 = 0 ;
20445 PyObject * obj2 = 0 ;
20446 char * kwnames[] = {
20447 (char *) "self",(char *) "key",(char *) "value", NULL
20448 };
20449
20450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20452 if (!SWIG_IsOK(res1)) {
20453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20454 }
20455 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20456 {
20457 arg2 = wxString_in_helper(obj1);
20458 if (arg2 == NULL) SWIG_fail;
20459 temp2 = true;
20460 }
20461 ecode3 = SWIG_AsVal_long(obj2, &val3);
20462 if (!SWIG_IsOK(ecode3)) {
20463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20464 }
20465 arg3 = static_cast< long >(val3);
20466 {
20467 PyThreadState* __tstate = wxPyBeginAllowThreads();
20468 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20469 wxPyEndAllowThreads(__tstate);
20470 if (PyErr_Occurred()) SWIG_fail;
20471 }
20472 {
20473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20474 }
20475 {
20476 if (temp2)
20477 delete arg2;
20478 }
20479 return resultobj;
20480 fail:
20481 {
20482 if (temp2)
20483 delete arg2;
20484 }
20485 return NULL;
20486 }
20487
20488
20489 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20490 PyObject *resultobj = 0;
20491 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20492 wxString *arg2 = 0 ;
20493 double arg3 ;
20494 bool result;
20495 void *argp1 = 0 ;
20496 int res1 = 0 ;
20497 bool temp2 = false ;
20498 double val3 ;
20499 int ecode3 = 0 ;
20500 PyObject * obj0 = 0 ;
20501 PyObject * obj1 = 0 ;
20502 PyObject * obj2 = 0 ;
20503 char * kwnames[] = {
20504 (char *) "self",(char *) "key",(char *) "value", NULL
20505 };
20506
20507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20509 if (!SWIG_IsOK(res1)) {
20510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20511 }
20512 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20513 {
20514 arg2 = wxString_in_helper(obj1);
20515 if (arg2 == NULL) SWIG_fail;
20516 temp2 = true;
20517 }
20518 ecode3 = SWIG_AsVal_double(obj2, &val3);
20519 if (!SWIG_IsOK(ecode3)) {
20520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20521 }
20522 arg3 = static_cast< double >(val3);
20523 {
20524 PyThreadState* __tstate = wxPyBeginAllowThreads();
20525 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 {
20530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20531 }
20532 {
20533 if (temp2)
20534 delete arg2;
20535 }
20536 return resultobj;
20537 fail:
20538 {
20539 if (temp2)
20540 delete arg2;
20541 }
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20547 PyObject *resultobj = 0;
20548 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20549 wxString *arg2 = 0 ;
20550 bool arg3 ;
20551 bool result;
20552 void *argp1 = 0 ;
20553 int res1 = 0 ;
20554 bool temp2 = false ;
20555 bool val3 ;
20556 int ecode3 = 0 ;
20557 PyObject * obj0 = 0 ;
20558 PyObject * obj1 = 0 ;
20559 PyObject * obj2 = 0 ;
20560 char * kwnames[] = {
20561 (char *) "self",(char *) "key",(char *) "value", NULL
20562 };
20563
20564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20566 if (!SWIG_IsOK(res1)) {
20567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20568 }
20569 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20570 {
20571 arg2 = wxString_in_helper(obj1);
20572 if (arg2 == NULL) SWIG_fail;
20573 temp2 = true;
20574 }
20575 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20576 if (!SWIG_IsOK(ecode3)) {
20577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20578 }
20579 arg3 = static_cast< bool >(val3);
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 {
20590 if (temp2)
20591 delete arg2;
20592 }
20593 return resultobj;
20594 fail:
20595 {
20596 if (temp2)
20597 delete arg2;
20598 }
20599 return NULL;
20600 }
20601
20602
20603 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20604 PyObject *resultobj = 0;
20605 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20606 bool arg2 = (bool) false ;
20607 bool result;
20608 void *argp1 = 0 ;
20609 int res1 = 0 ;
20610 bool val2 ;
20611 int ecode2 = 0 ;
20612 PyObject * obj0 = 0 ;
20613 PyObject * obj1 = 0 ;
20614 char * kwnames[] = {
20615 (char *) "self",(char *) "currentOnly", NULL
20616 };
20617
20618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20620 if (!SWIG_IsOK(res1)) {
20621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20622 }
20623 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20624 if (obj1) {
20625 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20626 if (!SWIG_IsOK(ecode2)) {
20627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20628 }
20629 arg2 = static_cast< bool >(val2);
20630 }
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 result = (bool)(arg1)->Flush(arg2);
20634 wxPyEndAllowThreads(__tstate);
20635 if (PyErr_Occurred()) SWIG_fail;
20636 }
20637 {
20638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20639 }
20640 return resultobj;
20641 fail:
20642 return NULL;
20643 }
20644
20645
20646 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20647 PyObject *resultobj = 0;
20648 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20649 wxString *arg2 = 0 ;
20650 wxString *arg3 = 0 ;
20651 bool result;
20652 void *argp1 = 0 ;
20653 int res1 = 0 ;
20654 bool temp2 = false ;
20655 bool temp3 = false ;
20656 PyObject * obj0 = 0 ;
20657 PyObject * obj1 = 0 ;
20658 PyObject * obj2 = 0 ;
20659 char * kwnames[] = {
20660 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20661 };
20662
20663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20665 if (!SWIG_IsOK(res1)) {
20666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20667 }
20668 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20669 {
20670 arg2 = wxString_in_helper(obj1);
20671 if (arg2 == NULL) SWIG_fail;
20672 temp2 = true;
20673 }
20674 {
20675 arg3 = wxString_in_helper(obj2);
20676 if (arg3 == NULL) SWIG_fail;
20677 temp3 = true;
20678 }
20679 {
20680 PyThreadState* __tstate = wxPyBeginAllowThreads();
20681 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20682 wxPyEndAllowThreads(__tstate);
20683 if (PyErr_Occurred()) SWIG_fail;
20684 }
20685 {
20686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20687 }
20688 {
20689 if (temp2)
20690 delete arg2;
20691 }
20692 {
20693 if (temp3)
20694 delete arg3;
20695 }
20696 return resultobj;
20697 fail:
20698 {
20699 if (temp2)
20700 delete arg2;
20701 }
20702 {
20703 if (temp3)
20704 delete arg3;
20705 }
20706 return NULL;
20707 }
20708
20709
20710 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20711 PyObject *resultobj = 0;
20712 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20713 wxString *arg2 = 0 ;
20714 wxString *arg3 = 0 ;
20715 bool result;
20716 void *argp1 = 0 ;
20717 int res1 = 0 ;
20718 bool temp2 = false ;
20719 bool temp3 = false ;
20720 PyObject * obj0 = 0 ;
20721 PyObject * obj1 = 0 ;
20722 PyObject * obj2 = 0 ;
20723 char * kwnames[] = {
20724 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20725 };
20726
20727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20729 if (!SWIG_IsOK(res1)) {
20730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20731 }
20732 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20733 {
20734 arg2 = wxString_in_helper(obj1);
20735 if (arg2 == NULL) SWIG_fail;
20736 temp2 = true;
20737 }
20738 {
20739 arg3 = wxString_in_helper(obj2);
20740 if (arg3 == NULL) SWIG_fail;
20741 temp3 = true;
20742 }
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20746 wxPyEndAllowThreads(__tstate);
20747 if (PyErr_Occurred()) SWIG_fail;
20748 }
20749 {
20750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20751 }
20752 {
20753 if (temp2)
20754 delete arg2;
20755 }
20756 {
20757 if (temp3)
20758 delete arg3;
20759 }
20760 return resultobj;
20761 fail:
20762 {
20763 if (temp2)
20764 delete arg2;
20765 }
20766 {
20767 if (temp3)
20768 delete arg3;
20769 }
20770 return NULL;
20771 }
20772
20773
20774 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20775 PyObject *resultobj = 0;
20776 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20777 wxString *arg2 = 0 ;
20778 bool arg3 = (bool) true ;
20779 bool result;
20780 void *argp1 = 0 ;
20781 int res1 = 0 ;
20782 bool temp2 = false ;
20783 bool val3 ;
20784 int ecode3 = 0 ;
20785 PyObject * obj0 = 0 ;
20786 PyObject * obj1 = 0 ;
20787 PyObject * obj2 = 0 ;
20788 char * kwnames[] = {
20789 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20790 };
20791
20792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20794 if (!SWIG_IsOK(res1)) {
20795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20796 }
20797 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20798 {
20799 arg2 = wxString_in_helper(obj1);
20800 if (arg2 == NULL) SWIG_fail;
20801 temp2 = true;
20802 }
20803 if (obj2) {
20804 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20805 if (!SWIG_IsOK(ecode3)) {
20806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20807 }
20808 arg3 = static_cast< bool >(val3);
20809 }
20810 {
20811 PyThreadState* __tstate = wxPyBeginAllowThreads();
20812 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20813 wxPyEndAllowThreads(__tstate);
20814 if (PyErr_Occurred()) SWIG_fail;
20815 }
20816 {
20817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20818 }
20819 {
20820 if (temp2)
20821 delete arg2;
20822 }
20823 return resultobj;
20824 fail:
20825 {
20826 if (temp2)
20827 delete arg2;
20828 }
20829 return NULL;
20830 }
20831
20832
20833 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20834 PyObject *resultobj = 0;
20835 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20836 wxString *arg2 = 0 ;
20837 bool result;
20838 void *argp1 = 0 ;
20839 int res1 = 0 ;
20840 bool temp2 = false ;
20841 PyObject * obj0 = 0 ;
20842 PyObject * obj1 = 0 ;
20843 char * kwnames[] = {
20844 (char *) "self",(char *) "key", NULL
20845 };
20846
20847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20849 if (!SWIG_IsOK(res1)) {
20850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20851 }
20852 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20853 {
20854 arg2 = wxString_in_helper(obj1);
20855 if (arg2 == NULL) SWIG_fail;
20856 temp2 = true;
20857 }
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 {
20865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20866 }
20867 {
20868 if (temp2)
20869 delete arg2;
20870 }
20871 return resultobj;
20872 fail:
20873 {
20874 if (temp2)
20875 delete arg2;
20876 }
20877 return NULL;
20878 }
20879
20880
20881 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20882 PyObject *resultobj = 0;
20883 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20884 bool result;
20885 void *argp1 = 0 ;
20886 int res1 = 0 ;
20887 PyObject *swig_obj[1] ;
20888
20889 if (!args) SWIG_fail;
20890 swig_obj[0] = args;
20891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20892 if (!SWIG_IsOK(res1)) {
20893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20894 }
20895 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = (bool)(arg1)->DeleteAll();
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 {
20903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20904 }
20905 return resultobj;
20906 fail:
20907 return NULL;
20908 }
20909
20910
20911 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20912 PyObject *resultobj = 0;
20913 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20914 bool arg2 = (bool) true ;
20915 void *argp1 = 0 ;
20916 int res1 = 0 ;
20917 bool val2 ;
20918 int ecode2 = 0 ;
20919 PyObject * obj0 = 0 ;
20920 PyObject * obj1 = 0 ;
20921 char * kwnames[] = {
20922 (char *) "self",(char *) "doIt", NULL
20923 };
20924
20925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20927 if (!SWIG_IsOK(res1)) {
20928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20929 }
20930 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20931 if (obj1) {
20932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20933 if (!SWIG_IsOK(ecode2)) {
20934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20935 }
20936 arg2 = static_cast< bool >(val2);
20937 }
20938 {
20939 PyThreadState* __tstate = wxPyBeginAllowThreads();
20940 (arg1)->SetExpandEnvVars(arg2);
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 resultobj = SWIG_Py_Void();
20945 return resultobj;
20946 fail:
20947 return NULL;
20948 }
20949
20950
20951 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20952 PyObject *resultobj = 0;
20953 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20954 bool result;
20955 void *argp1 = 0 ;
20956 int res1 = 0 ;
20957 PyObject *swig_obj[1] ;
20958
20959 if (!args) SWIG_fail;
20960 swig_obj[0] = args;
20961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20962 if (!SWIG_IsOK(res1)) {
20963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20964 }
20965 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20966 {
20967 PyThreadState* __tstate = wxPyBeginAllowThreads();
20968 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20969 wxPyEndAllowThreads(__tstate);
20970 if (PyErr_Occurred()) SWIG_fail;
20971 }
20972 {
20973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20974 }
20975 return resultobj;
20976 fail:
20977 return NULL;
20978 }
20979
20980
20981 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20982 PyObject *resultobj = 0;
20983 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20984 bool arg2 = (bool) true ;
20985 void *argp1 = 0 ;
20986 int res1 = 0 ;
20987 bool val2 ;
20988 int ecode2 = 0 ;
20989 PyObject * obj0 = 0 ;
20990 PyObject * obj1 = 0 ;
20991 char * kwnames[] = {
20992 (char *) "self",(char *) "doIt", NULL
20993 };
20994
20995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
20996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20997 if (!SWIG_IsOK(res1)) {
20998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20999 }
21000 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21001 if (obj1) {
21002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21003 if (!SWIG_IsOK(ecode2)) {
21004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21005 }
21006 arg2 = static_cast< bool >(val2);
21007 }
21008 {
21009 PyThreadState* __tstate = wxPyBeginAllowThreads();
21010 (arg1)->SetRecordDefaults(arg2);
21011 wxPyEndAllowThreads(__tstate);
21012 if (PyErr_Occurred()) SWIG_fail;
21013 }
21014 resultobj = SWIG_Py_Void();
21015 return resultobj;
21016 fail:
21017 return NULL;
21018 }
21019
21020
21021 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21022 PyObject *resultobj = 0;
21023 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21024 bool result;
21025 void *argp1 = 0 ;
21026 int res1 = 0 ;
21027 PyObject *swig_obj[1] ;
21028
21029 if (!args) SWIG_fail;
21030 swig_obj[0] = args;
21031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21032 if (!SWIG_IsOK(res1)) {
21033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21034 }
21035 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21039 wxPyEndAllowThreads(__tstate);
21040 if (PyErr_Occurred()) SWIG_fail;
21041 }
21042 {
21043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21044 }
21045 return resultobj;
21046 fail:
21047 return NULL;
21048 }
21049
21050
21051 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21052 PyObject *resultobj = 0;
21053 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21054 wxString *arg2 = 0 ;
21055 wxString result;
21056 void *argp1 = 0 ;
21057 int res1 = 0 ;
21058 bool temp2 = false ;
21059 PyObject * obj0 = 0 ;
21060 PyObject * obj1 = 0 ;
21061 char * kwnames[] = {
21062 (char *) "self",(char *) "str", NULL
21063 };
21064
21065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21067 if (!SWIG_IsOK(res1)) {
21068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21069 }
21070 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21071 {
21072 arg2 = wxString_in_helper(obj1);
21073 if (arg2 == NULL) SWIG_fail;
21074 temp2 = true;
21075 }
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 {
21083 #if wxUSE_UNICODE
21084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21085 #else
21086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21087 #endif
21088 }
21089 {
21090 if (temp2)
21091 delete arg2;
21092 }
21093 return resultobj;
21094 fail:
21095 {
21096 if (temp2)
21097 delete arg2;
21098 }
21099 return NULL;
21100 }
21101
21102
21103 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21104 PyObject *resultobj = 0;
21105 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21106 wxString result;
21107 void *argp1 = 0 ;
21108 int res1 = 0 ;
21109 PyObject *swig_obj[1] ;
21110
21111 if (!args) SWIG_fail;
21112 swig_obj[0] = args;
21113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21116 }
21117 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 result = ((wxConfigBase const *)arg1)->GetAppName();
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 {
21125 #if wxUSE_UNICODE
21126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21127 #else
21128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21129 #endif
21130 }
21131 return resultobj;
21132 fail:
21133 return NULL;
21134 }
21135
21136
21137 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21138 PyObject *resultobj = 0;
21139 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21140 wxString result;
21141 void *argp1 = 0 ;
21142 int res1 = 0 ;
21143 PyObject *swig_obj[1] ;
21144
21145 if (!args) SWIG_fail;
21146 swig_obj[0] = args;
21147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21148 if (!SWIG_IsOK(res1)) {
21149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21150 }
21151 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = ((wxConfigBase const *)arg1)->GetVendorName();
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 {
21159 #if wxUSE_UNICODE
21160 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21161 #else
21162 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21163 #endif
21164 }
21165 return resultobj;
21166 fail:
21167 return NULL;
21168 }
21169
21170
21171 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21172 PyObject *resultobj = 0;
21173 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21174 wxString *arg2 = 0 ;
21175 void *argp1 = 0 ;
21176 int res1 = 0 ;
21177 bool temp2 = false ;
21178 PyObject * obj0 = 0 ;
21179 PyObject * obj1 = 0 ;
21180 char * kwnames[] = {
21181 (char *) "self",(char *) "appName", NULL
21182 };
21183
21184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21188 }
21189 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21190 {
21191 arg2 = wxString_in_helper(obj1);
21192 if (arg2 == NULL) SWIG_fail;
21193 temp2 = true;
21194 }
21195 {
21196 PyThreadState* __tstate = wxPyBeginAllowThreads();
21197 (arg1)->SetAppName((wxString const &)*arg2);
21198 wxPyEndAllowThreads(__tstate);
21199 if (PyErr_Occurred()) SWIG_fail;
21200 }
21201 resultobj = SWIG_Py_Void();
21202 {
21203 if (temp2)
21204 delete arg2;
21205 }
21206 return resultobj;
21207 fail:
21208 {
21209 if (temp2)
21210 delete arg2;
21211 }
21212 return NULL;
21213 }
21214
21215
21216 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21217 PyObject *resultobj = 0;
21218 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21219 wxString *arg2 = 0 ;
21220 void *argp1 = 0 ;
21221 int res1 = 0 ;
21222 bool temp2 = false ;
21223 PyObject * obj0 = 0 ;
21224 PyObject * obj1 = 0 ;
21225 char * kwnames[] = {
21226 (char *) "self",(char *) "vendorName", NULL
21227 };
21228
21229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21231 if (!SWIG_IsOK(res1)) {
21232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21233 }
21234 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21235 {
21236 arg2 = wxString_in_helper(obj1);
21237 if (arg2 == NULL) SWIG_fail;
21238 temp2 = true;
21239 }
21240 {
21241 PyThreadState* __tstate = wxPyBeginAllowThreads();
21242 (arg1)->SetVendorName((wxString const &)*arg2);
21243 wxPyEndAllowThreads(__tstate);
21244 if (PyErr_Occurred()) SWIG_fail;
21245 }
21246 resultobj = SWIG_Py_Void();
21247 {
21248 if (temp2)
21249 delete arg2;
21250 }
21251 return resultobj;
21252 fail:
21253 {
21254 if (temp2)
21255 delete arg2;
21256 }
21257 return NULL;
21258 }
21259
21260
21261 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21262 PyObject *resultobj = 0;
21263 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21264 long arg2 ;
21265 void *argp1 = 0 ;
21266 int res1 = 0 ;
21267 long val2 ;
21268 int ecode2 = 0 ;
21269 PyObject * obj0 = 0 ;
21270 PyObject * obj1 = 0 ;
21271 char * kwnames[] = {
21272 (char *) "self",(char *) "style", NULL
21273 };
21274
21275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21279 }
21280 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21281 ecode2 = SWIG_AsVal_long(obj1, &val2);
21282 if (!SWIG_IsOK(ecode2)) {
21283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21284 }
21285 arg2 = static_cast< long >(val2);
21286 {
21287 PyThreadState* __tstate = wxPyBeginAllowThreads();
21288 (arg1)->SetStyle(arg2);
21289 wxPyEndAllowThreads(__tstate);
21290 if (PyErr_Occurred()) SWIG_fail;
21291 }
21292 resultobj = SWIG_Py_Void();
21293 return resultobj;
21294 fail:
21295 return NULL;
21296 }
21297
21298
21299 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21300 PyObject *resultobj = 0;
21301 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21302 long result;
21303 void *argp1 = 0 ;
21304 int res1 = 0 ;
21305 PyObject *swig_obj[1] ;
21306
21307 if (!args) SWIG_fail;
21308 swig_obj[0] = args;
21309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21310 if (!SWIG_IsOK(res1)) {
21311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21312 }
21313 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21314 {
21315 PyThreadState* __tstate = wxPyBeginAllowThreads();
21316 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21317 wxPyEndAllowThreads(__tstate);
21318 if (PyErr_Occurred()) SWIG_fail;
21319 }
21320 resultobj = SWIG_From_long(static_cast< long >(result));
21321 return resultobj;
21322 fail:
21323 return NULL;
21324 }
21325
21326
21327 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21328 PyObject *obj;
21329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21330 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21331 return SWIG_Py_Void();
21332 }
21333
21334 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21335 PyObject *resultobj = 0;
21336 wxString const &arg1_defvalue = wxPyEmptyString ;
21337 wxString *arg1 = (wxString *) &arg1_defvalue ;
21338 wxString const &arg2_defvalue = wxPyEmptyString ;
21339 wxString *arg2 = (wxString *) &arg2_defvalue ;
21340 wxString const &arg3_defvalue = wxPyEmptyString ;
21341 wxString *arg3 = (wxString *) &arg3_defvalue ;
21342 wxString const &arg4_defvalue = wxPyEmptyString ;
21343 wxString *arg4 = (wxString *) &arg4_defvalue ;
21344 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21345 wxConfig *result = 0 ;
21346 bool temp1 = false ;
21347 bool temp2 = false ;
21348 bool temp3 = false ;
21349 bool temp4 = false ;
21350 long val5 ;
21351 int ecode5 = 0 ;
21352 PyObject * obj0 = 0 ;
21353 PyObject * obj1 = 0 ;
21354 PyObject * obj2 = 0 ;
21355 PyObject * obj3 = 0 ;
21356 PyObject * obj4 = 0 ;
21357 char * kwnames[] = {
21358 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21359 };
21360
21361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21362 if (obj0) {
21363 {
21364 arg1 = wxString_in_helper(obj0);
21365 if (arg1 == NULL) SWIG_fail;
21366 temp1 = true;
21367 }
21368 }
21369 if (obj1) {
21370 {
21371 arg2 = wxString_in_helper(obj1);
21372 if (arg2 == NULL) SWIG_fail;
21373 temp2 = true;
21374 }
21375 }
21376 if (obj2) {
21377 {
21378 arg3 = wxString_in_helper(obj2);
21379 if (arg3 == NULL) SWIG_fail;
21380 temp3 = true;
21381 }
21382 }
21383 if (obj3) {
21384 {
21385 arg4 = wxString_in_helper(obj3);
21386 if (arg4 == NULL) SWIG_fail;
21387 temp4 = true;
21388 }
21389 }
21390 if (obj4) {
21391 ecode5 = SWIG_AsVal_long(obj4, &val5);
21392 if (!SWIG_IsOK(ecode5)) {
21393 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21394 }
21395 arg5 = static_cast< long >(val5);
21396 }
21397 {
21398 PyThreadState* __tstate = wxPyBeginAllowThreads();
21399 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21404 {
21405 if (temp1)
21406 delete arg1;
21407 }
21408 {
21409 if (temp2)
21410 delete arg2;
21411 }
21412 {
21413 if (temp3)
21414 delete arg3;
21415 }
21416 {
21417 if (temp4)
21418 delete arg4;
21419 }
21420 return resultobj;
21421 fail:
21422 {
21423 if (temp1)
21424 delete arg1;
21425 }
21426 {
21427 if (temp2)
21428 delete arg2;
21429 }
21430 {
21431 if (temp3)
21432 delete arg3;
21433 }
21434 {
21435 if (temp4)
21436 delete arg4;
21437 }
21438 return NULL;
21439 }
21440
21441
21442 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21443 PyObject *resultobj = 0;
21444 wxConfig *arg1 = (wxConfig *) 0 ;
21445 void *argp1 = 0 ;
21446 int res1 = 0 ;
21447 PyObject *swig_obj[1] ;
21448
21449 if (!args) SWIG_fail;
21450 swig_obj[0] = args;
21451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21452 if (!SWIG_IsOK(res1)) {
21453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21454 }
21455 arg1 = reinterpret_cast< wxConfig * >(argp1);
21456 {
21457 PyThreadState* __tstate = wxPyBeginAllowThreads();
21458 delete arg1;
21459
21460 wxPyEndAllowThreads(__tstate);
21461 if (PyErr_Occurred()) SWIG_fail;
21462 }
21463 resultobj = SWIG_Py_Void();
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21471 PyObject *obj;
21472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21473 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21474 return SWIG_Py_Void();
21475 }
21476
21477 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21478 return SWIG_Python_InitShadowInstance(args);
21479 }
21480
21481 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21482 PyObject *resultobj = 0;
21483 wxString const &arg1_defvalue = wxPyEmptyString ;
21484 wxString *arg1 = (wxString *) &arg1_defvalue ;
21485 wxString const &arg2_defvalue = wxPyEmptyString ;
21486 wxString *arg2 = (wxString *) &arg2_defvalue ;
21487 wxString const &arg3_defvalue = wxPyEmptyString ;
21488 wxString *arg3 = (wxString *) &arg3_defvalue ;
21489 wxString const &arg4_defvalue = wxPyEmptyString ;
21490 wxString *arg4 = (wxString *) &arg4_defvalue ;
21491 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21492 wxFileConfig *result = 0 ;
21493 bool temp1 = false ;
21494 bool temp2 = false ;
21495 bool temp3 = false ;
21496 bool temp4 = false ;
21497 long val5 ;
21498 int ecode5 = 0 ;
21499 PyObject * obj0 = 0 ;
21500 PyObject * obj1 = 0 ;
21501 PyObject * obj2 = 0 ;
21502 PyObject * obj3 = 0 ;
21503 PyObject * obj4 = 0 ;
21504 char * kwnames[] = {
21505 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21506 };
21507
21508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21509 if (obj0) {
21510 {
21511 arg1 = wxString_in_helper(obj0);
21512 if (arg1 == NULL) SWIG_fail;
21513 temp1 = true;
21514 }
21515 }
21516 if (obj1) {
21517 {
21518 arg2 = wxString_in_helper(obj1);
21519 if (arg2 == NULL) SWIG_fail;
21520 temp2 = true;
21521 }
21522 }
21523 if (obj2) {
21524 {
21525 arg3 = wxString_in_helper(obj2);
21526 if (arg3 == NULL) SWIG_fail;
21527 temp3 = true;
21528 }
21529 }
21530 if (obj3) {
21531 {
21532 arg4 = wxString_in_helper(obj3);
21533 if (arg4 == NULL) SWIG_fail;
21534 temp4 = true;
21535 }
21536 }
21537 if (obj4) {
21538 ecode5 = SWIG_AsVal_long(obj4, &val5);
21539 if (!SWIG_IsOK(ecode5)) {
21540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21541 }
21542 arg5 = static_cast< long >(val5);
21543 }
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21551 {
21552 if (temp1)
21553 delete arg1;
21554 }
21555 {
21556 if (temp2)
21557 delete arg2;
21558 }
21559 {
21560 if (temp3)
21561 delete arg3;
21562 }
21563 {
21564 if (temp4)
21565 delete arg4;
21566 }
21567 return resultobj;
21568 fail:
21569 {
21570 if (temp1)
21571 delete arg1;
21572 }
21573 {
21574 if (temp2)
21575 delete arg2;
21576 }
21577 {
21578 if (temp3)
21579 delete arg3;
21580 }
21581 {
21582 if (temp4)
21583 delete arg4;
21584 }
21585 return NULL;
21586 }
21587
21588
21589 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21590 PyObject *resultobj = 0;
21591 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 PyObject *swig_obj[1] ;
21595
21596 if (!args) SWIG_fail;
21597 swig_obj[0] = args;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21601 }
21602 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 delete arg1;
21606
21607 wxPyEndAllowThreads(__tstate);
21608 if (PyErr_Occurred()) SWIG_fail;
21609 }
21610 resultobj = SWIG_Py_Void();
21611 return resultobj;
21612 fail:
21613 return NULL;
21614 }
21615
21616
21617 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21618 PyObject *obj;
21619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21620 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21621 return SWIG_Py_Void();
21622 }
21623
21624 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21625 return SWIG_Python_InitShadowInstance(args);
21626 }
21627
21628 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21629 PyObject *resultobj = 0;
21630 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21631 wxString *arg2 = 0 ;
21632 wxConfigPathChanger *result = 0 ;
21633 void *argp1 = 0 ;
21634 int res1 = 0 ;
21635 bool temp2 = false ;
21636 PyObject * obj0 = 0 ;
21637 PyObject * obj1 = 0 ;
21638 char * kwnames[] = {
21639 (char *) "config",(char *) "entry", NULL
21640 };
21641
21642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21644 if (!SWIG_IsOK(res1)) {
21645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21646 }
21647 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21648 {
21649 arg2 = wxString_in_helper(obj1);
21650 if (arg2 == NULL) SWIG_fail;
21651 temp2 = true;
21652 }
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21656 wxPyEndAllowThreads(__tstate);
21657 if (PyErr_Occurred()) SWIG_fail;
21658 }
21659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21660 {
21661 if (temp2)
21662 delete arg2;
21663 }
21664 return resultobj;
21665 fail:
21666 {
21667 if (temp2)
21668 delete arg2;
21669 }
21670 return NULL;
21671 }
21672
21673
21674 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21675 PyObject *resultobj = 0;
21676 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21677 void *argp1 = 0 ;
21678 int res1 = 0 ;
21679 PyObject *swig_obj[1] ;
21680
21681 if (!args) SWIG_fail;
21682 swig_obj[0] = args;
21683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21684 if (!SWIG_IsOK(res1)) {
21685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21686 }
21687 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21688 {
21689 PyThreadState* __tstate = wxPyBeginAllowThreads();
21690 delete arg1;
21691
21692 wxPyEndAllowThreads(__tstate);
21693 if (PyErr_Occurred()) SWIG_fail;
21694 }
21695 resultobj = SWIG_Py_Void();
21696 return resultobj;
21697 fail:
21698 return NULL;
21699 }
21700
21701
21702 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21703 PyObject *resultobj = 0;
21704 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21705 wxString *result = 0 ;
21706 void *argp1 = 0 ;
21707 int res1 = 0 ;
21708 PyObject *swig_obj[1] ;
21709
21710 if (!args) SWIG_fail;
21711 swig_obj[0] = args;
21712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21713 if (!SWIG_IsOK(res1)) {
21714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21715 }
21716 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21717 {
21718 PyThreadState* __tstate = wxPyBeginAllowThreads();
21719 {
21720 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21721 result = (wxString *) &_result_ref;
21722 }
21723 wxPyEndAllowThreads(__tstate);
21724 if (PyErr_Occurred()) SWIG_fail;
21725 }
21726 {
21727 #if wxUSE_UNICODE
21728 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21729 #else
21730 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21731 #endif
21732 }
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 PyObject *obj;
21741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21742 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21743 return SWIG_Py_Void();
21744 }
21745
21746 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21747 return SWIG_Python_InitShadowInstance(args);
21748 }
21749
21750 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21751 PyObject *resultobj = 0;
21752 wxString *arg1 = 0 ;
21753 wxString result;
21754 bool temp1 = false ;
21755 PyObject * obj0 = 0 ;
21756 char * kwnames[] = {
21757 (char *) "sz", NULL
21758 };
21759
21760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21761 {
21762 arg1 = wxString_in_helper(obj0);
21763 if (arg1 == NULL) SWIG_fail;
21764 temp1 = true;
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = wxExpandEnvVars((wxString const &)*arg1);
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 {
21773 #if wxUSE_UNICODE
21774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21775 #else
21776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21777 #endif
21778 }
21779 {
21780 if (temp1)
21781 delete arg1;
21782 }
21783 return resultobj;
21784 fail:
21785 {
21786 if (temp1)
21787 delete arg1;
21788 }
21789 return NULL;
21790 }
21791
21792
21793 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21794 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21795 return 1;
21796 }
21797
21798
21799 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21800 PyObject *pyobj = 0;
21801
21802 {
21803 #if wxUSE_UNICODE
21804 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21805 #else
21806 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21807 #endif
21808 }
21809 return pyobj;
21810 }
21811
21812
21813 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21814 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21815 return 1;
21816 }
21817
21818
21819 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21820 PyObject *pyobj = 0;
21821
21822 {
21823 #if wxUSE_UNICODE
21824 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21825 #else
21826 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21827 #endif
21828 }
21829 return pyobj;
21830 }
21831
21832
21833 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21834 PyObject *resultobj = 0;
21835 wxDateTime::Country arg1 ;
21836 int val1 ;
21837 int ecode1 = 0 ;
21838 PyObject * obj0 = 0 ;
21839 char * kwnames[] = {
21840 (char *) "country", NULL
21841 };
21842
21843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21844 ecode1 = SWIG_AsVal_int(obj0, &val1);
21845 if (!SWIG_IsOK(ecode1)) {
21846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21847 }
21848 arg1 = static_cast< wxDateTime::Country >(val1);
21849 {
21850 PyThreadState* __tstate = wxPyBeginAllowThreads();
21851 wxDateTime::SetCountry(arg1);
21852 wxPyEndAllowThreads(__tstate);
21853 if (PyErr_Occurred()) SWIG_fail;
21854 }
21855 resultobj = SWIG_Py_Void();
21856 return resultobj;
21857 fail:
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21863 PyObject *resultobj = 0;
21864 wxDateTime::Country result;
21865
21866 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = (wxDateTime::Country)wxDateTime::GetCountry();
21870 wxPyEndAllowThreads(__tstate);
21871 if (PyErr_Occurred()) SWIG_fail;
21872 }
21873 resultobj = SWIG_From_int(static_cast< int >(result));
21874 return resultobj;
21875 fail:
21876 return NULL;
21877 }
21878
21879
21880 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21881 PyObject *resultobj = 0;
21882 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21883 bool result;
21884 int val1 ;
21885 int ecode1 = 0 ;
21886 PyObject * obj0 = 0 ;
21887 char * kwnames[] = {
21888 (char *) "country", NULL
21889 };
21890
21891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21892 if (obj0) {
21893 ecode1 = SWIG_AsVal_int(obj0, &val1);
21894 if (!SWIG_IsOK(ecode1)) {
21895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21896 }
21897 arg1 = static_cast< wxDateTime::Country >(val1);
21898 }
21899 {
21900 PyThreadState* __tstate = wxPyBeginAllowThreads();
21901 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21902 wxPyEndAllowThreads(__tstate);
21903 if (PyErr_Occurred()) SWIG_fail;
21904 }
21905 {
21906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21907 }
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21915 PyObject *resultobj = 0;
21916 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21917 int result;
21918 int val1 ;
21919 int ecode1 = 0 ;
21920 PyObject * obj0 = 0 ;
21921 char * kwnames[] = {
21922 (char *) "cal", NULL
21923 };
21924
21925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21926 if (obj0) {
21927 ecode1 = SWIG_AsVal_int(obj0, &val1);
21928 if (!SWIG_IsOK(ecode1)) {
21929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21930 }
21931 arg1 = static_cast< wxDateTime::Calendar >(val1);
21932 }
21933 {
21934 PyThreadState* __tstate = wxPyBeginAllowThreads();
21935 result = (int)wxDateTime::GetCurrentYear(arg1);
21936 wxPyEndAllowThreads(__tstate);
21937 if (PyErr_Occurred()) SWIG_fail;
21938 }
21939 resultobj = SWIG_From_int(static_cast< int >(result));
21940 return resultobj;
21941 fail:
21942 return NULL;
21943 }
21944
21945
21946 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21947 PyObject *resultobj = 0;
21948 int arg1 ;
21949 int result;
21950 int val1 ;
21951 int ecode1 = 0 ;
21952 PyObject * obj0 = 0 ;
21953 char * kwnames[] = {
21954 (char *) "year", NULL
21955 };
21956
21957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21958 ecode1 = SWIG_AsVal_int(obj0, &val1);
21959 if (!SWIG_IsOK(ecode1)) {
21960 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21961 }
21962 arg1 = static_cast< int >(val1);
21963 {
21964 PyThreadState* __tstate = wxPyBeginAllowThreads();
21965 result = (int)wxDateTime::ConvertYearToBC(arg1);
21966 wxPyEndAllowThreads(__tstate);
21967 if (PyErr_Occurred()) SWIG_fail;
21968 }
21969 resultobj = SWIG_From_int(static_cast< int >(result));
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21977 PyObject *resultobj = 0;
21978 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21979 wxDateTime::Month result;
21980 int val1 ;
21981 int ecode1 = 0 ;
21982 PyObject * obj0 = 0 ;
21983 char * kwnames[] = {
21984 (char *) "cal", NULL
21985 };
21986
21987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21988 if (obj0) {
21989 ecode1 = SWIG_AsVal_int(obj0, &val1);
21990 if (!SWIG_IsOK(ecode1)) {
21991 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21992 }
21993 arg1 = static_cast< wxDateTime::Calendar >(val1);
21994 }
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 resultobj = SWIG_From_int(static_cast< int >(result));
22002 return resultobj;
22003 fail:
22004 return NULL;
22005 }
22006
22007
22008 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22009 PyObject *resultobj = 0;
22010 int arg1 = (int) wxDateTime::Inv_Year ;
22011 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22012 bool result;
22013 int val1 ;
22014 int ecode1 = 0 ;
22015 int val2 ;
22016 int ecode2 = 0 ;
22017 PyObject * obj0 = 0 ;
22018 PyObject * obj1 = 0 ;
22019 char * kwnames[] = {
22020 (char *) "year",(char *) "cal", NULL
22021 };
22022
22023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22024 if (obj0) {
22025 ecode1 = SWIG_AsVal_int(obj0, &val1);
22026 if (!SWIG_IsOK(ecode1)) {
22027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22028 }
22029 arg1 = static_cast< int >(val1);
22030 }
22031 if (obj1) {
22032 ecode2 = SWIG_AsVal_int(obj1, &val2);
22033 if (!SWIG_IsOK(ecode2)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22035 }
22036 arg2 = static_cast< wxDateTime::Calendar >(val2);
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 {
22045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22046 }
22047 return resultobj;
22048 fail:
22049 return NULL;
22050 }
22051
22052
22053 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22054 PyObject *resultobj = 0;
22055 int arg1 = (int) wxDateTime::Inv_Year ;
22056 int result;
22057 int val1 ;
22058 int ecode1 = 0 ;
22059 PyObject * obj0 = 0 ;
22060 char * kwnames[] = {
22061 (char *) "year", NULL
22062 };
22063
22064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22065 if (obj0) {
22066 ecode1 = SWIG_AsVal_int(obj0, &val1);
22067 if (!SWIG_IsOK(ecode1)) {
22068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22069 }
22070 arg1 = static_cast< int >(val1);
22071 }
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (int)wxDateTime::GetCentury(arg1);
22075 wxPyEndAllowThreads(__tstate);
22076 if (PyErr_Occurred()) SWIG_fail;
22077 }
22078 resultobj = SWIG_From_int(static_cast< int >(result));
22079 return resultobj;
22080 fail:
22081 return NULL;
22082 }
22083
22084
22085 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22086 PyObject *resultobj = 0;
22087 int arg1 ;
22088 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22089 int result;
22090 int val1 ;
22091 int ecode1 = 0 ;
22092 int val2 ;
22093 int ecode2 = 0 ;
22094 PyObject * obj0 = 0 ;
22095 PyObject * obj1 = 0 ;
22096 char * kwnames[] = {
22097 (char *) "year",(char *) "cal", NULL
22098 };
22099
22100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22101 ecode1 = SWIG_AsVal_int(obj0, &val1);
22102 if (!SWIG_IsOK(ecode1)) {
22103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22104 }
22105 arg1 = static_cast< int >(val1);
22106 if (obj1) {
22107 ecode2 = SWIG_AsVal_int(obj1, &val2);
22108 if (!SWIG_IsOK(ecode2)) {
22109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22110 }
22111 arg2 = static_cast< wxDateTime::Calendar >(val2);
22112 }
22113 {
22114 PyThreadState* __tstate = wxPyBeginAllowThreads();
22115 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22116 wxPyEndAllowThreads(__tstate);
22117 if (PyErr_Occurred()) SWIG_fail;
22118 }
22119 resultobj = SWIG_From_int(static_cast< int >(result));
22120 return resultobj;
22121 fail:
22122 return NULL;
22123 }
22124
22125
22126 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22127 PyObject *resultobj = 0;
22128 wxDateTime::Month arg1 ;
22129 int arg2 = (int) wxDateTime::Inv_Year ;
22130 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22131 int result;
22132 int val1 ;
22133 int ecode1 = 0 ;
22134 int val2 ;
22135 int ecode2 = 0 ;
22136 int val3 ;
22137 int ecode3 = 0 ;
22138 PyObject * obj0 = 0 ;
22139 PyObject * obj1 = 0 ;
22140 PyObject * obj2 = 0 ;
22141 char * kwnames[] = {
22142 (char *) "month",(char *) "year",(char *) "cal", NULL
22143 };
22144
22145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22146 ecode1 = SWIG_AsVal_int(obj0, &val1);
22147 if (!SWIG_IsOK(ecode1)) {
22148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22149 }
22150 arg1 = static_cast< wxDateTime::Month >(val1);
22151 if (obj1) {
22152 ecode2 = SWIG_AsVal_int(obj1, &val2);
22153 if (!SWIG_IsOK(ecode2)) {
22154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22155 }
22156 arg2 = static_cast< int >(val2);
22157 }
22158 if (obj2) {
22159 ecode3 = SWIG_AsVal_int(obj2, &val3);
22160 if (!SWIG_IsOK(ecode3)) {
22161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22162 }
22163 arg3 = static_cast< wxDateTime::Calendar >(val3);
22164 }
22165 {
22166 PyThreadState* __tstate = wxPyBeginAllowThreads();
22167 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_From_int(static_cast< int >(result));
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj = 0;
22180 wxDateTime::Month arg1 ;
22181 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22182 wxString result;
22183 int val1 ;
22184 int ecode1 = 0 ;
22185 int val2 ;
22186 int ecode2 = 0 ;
22187 PyObject * obj0 = 0 ;
22188 PyObject * obj1 = 0 ;
22189 char * kwnames[] = {
22190 (char *) "month",(char *) "flags", NULL
22191 };
22192
22193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22194 ecode1 = SWIG_AsVal_int(obj0, &val1);
22195 if (!SWIG_IsOK(ecode1)) {
22196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22197 }
22198 arg1 = static_cast< wxDateTime::Month >(val1);
22199 if (obj1) {
22200 ecode2 = SWIG_AsVal_int(obj1, &val2);
22201 if (!SWIG_IsOK(ecode2)) {
22202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22203 }
22204 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22205 }
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 result = wxDateTime::GetMonthName(arg1,arg2);
22209 wxPyEndAllowThreads(__tstate);
22210 if (PyErr_Occurred()) SWIG_fail;
22211 }
22212 {
22213 #if wxUSE_UNICODE
22214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22215 #else
22216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22217 #endif
22218 }
22219 return resultobj;
22220 fail:
22221 return NULL;
22222 }
22223
22224
22225 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22226 PyObject *resultobj = 0;
22227 wxDateTime::WeekDay arg1 ;
22228 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22229 wxString result;
22230 int val1 ;
22231 int ecode1 = 0 ;
22232 int val2 ;
22233 int ecode2 = 0 ;
22234 PyObject * obj0 = 0 ;
22235 PyObject * obj1 = 0 ;
22236 char * kwnames[] = {
22237 (char *) "weekday",(char *) "flags", NULL
22238 };
22239
22240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22241 ecode1 = SWIG_AsVal_int(obj0, &val1);
22242 if (!SWIG_IsOK(ecode1)) {
22243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22244 }
22245 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22246 if (obj1) {
22247 ecode2 = SWIG_AsVal_int(obj1, &val2);
22248 if (!SWIG_IsOK(ecode2)) {
22249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22250 }
22251 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22252 }
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 result = wxDateTime::GetWeekDayName(arg1,arg2);
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 {
22260 #if wxUSE_UNICODE
22261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22262 #else
22263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22264 #endif
22265 }
22266 return resultobj;
22267 fail:
22268 return NULL;
22269 }
22270
22271
22272 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22273 PyObject *resultobj = 0;
22274 PyObject *result = 0 ;
22275
22276 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 result = (PyObject *)wxDateTime_GetAmPmStrings();
22280 wxPyEndAllowThreads(__tstate);
22281 if (PyErr_Occurred()) SWIG_fail;
22282 }
22283 resultobj = result;
22284 return resultobj;
22285 fail:
22286 return NULL;
22287 }
22288
22289
22290 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22291 PyObject *resultobj = 0;
22292 int arg1 = (int) wxDateTime::Inv_Year ;
22293 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22294 bool result;
22295 int val1 ;
22296 int ecode1 = 0 ;
22297 int val2 ;
22298 int ecode2 = 0 ;
22299 PyObject * obj0 = 0 ;
22300 PyObject * obj1 = 0 ;
22301 char * kwnames[] = {
22302 (char *) "year",(char *) "country", NULL
22303 };
22304
22305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22306 if (obj0) {
22307 ecode1 = SWIG_AsVal_int(obj0, &val1);
22308 if (!SWIG_IsOK(ecode1)) {
22309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22310 }
22311 arg1 = static_cast< int >(val1);
22312 }
22313 if (obj1) {
22314 ecode2 = SWIG_AsVal_int(obj1, &val2);
22315 if (!SWIG_IsOK(ecode2)) {
22316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22317 }
22318 arg2 = static_cast< wxDateTime::Country >(val2);
22319 }
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 {
22327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22328 }
22329 return resultobj;
22330 fail:
22331 return NULL;
22332 }
22333
22334
22335 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22336 PyObject *resultobj = 0;
22337 int arg1 = (int) wxDateTime::Inv_Year ;
22338 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22339 wxDateTime result;
22340 int val1 ;
22341 int ecode1 = 0 ;
22342 int val2 ;
22343 int ecode2 = 0 ;
22344 PyObject * obj0 = 0 ;
22345 PyObject * obj1 = 0 ;
22346 char * kwnames[] = {
22347 (char *) "year",(char *) "country", NULL
22348 };
22349
22350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22351 if (obj0) {
22352 ecode1 = SWIG_AsVal_int(obj0, &val1);
22353 if (!SWIG_IsOK(ecode1)) {
22354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22355 }
22356 arg1 = static_cast< int >(val1);
22357 }
22358 if (obj1) {
22359 ecode2 = SWIG_AsVal_int(obj1, &val2);
22360 if (!SWIG_IsOK(ecode2)) {
22361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22362 }
22363 arg2 = static_cast< wxDateTime::Country >(val2);
22364 }
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 result = wxDateTime::GetBeginDST(arg1,arg2);
22368 wxPyEndAllowThreads(__tstate);
22369 if (PyErr_Occurred()) SWIG_fail;
22370 }
22371 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22372 return resultobj;
22373 fail:
22374 return NULL;
22375 }
22376
22377
22378 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22379 PyObject *resultobj = 0;
22380 int arg1 = (int) wxDateTime::Inv_Year ;
22381 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22382 wxDateTime result;
22383 int val1 ;
22384 int ecode1 = 0 ;
22385 int val2 ;
22386 int ecode2 = 0 ;
22387 PyObject * obj0 = 0 ;
22388 PyObject * obj1 = 0 ;
22389 char * kwnames[] = {
22390 (char *) "year",(char *) "country", NULL
22391 };
22392
22393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22394 if (obj0) {
22395 ecode1 = SWIG_AsVal_int(obj0, &val1);
22396 if (!SWIG_IsOK(ecode1)) {
22397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22398 }
22399 arg1 = static_cast< int >(val1);
22400 }
22401 if (obj1) {
22402 ecode2 = SWIG_AsVal_int(obj1, &val2);
22403 if (!SWIG_IsOK(ecode2)) {
22404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22405 }
22406 arg2 = static_cast< wxDateTime::Country >(val2);
22407 }
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 result = wxDateTime::GetEndDST(arg1,arg2);
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22422 PyObject *resultobj = 0;
22423 wxDateTime result;
22424
22425 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22426 {
22427 PyThreadState* __tstate = wxPyBeginAllowThreads();
22428 result = wxDateTime::Now();
22429 wxPyEndAllowThreads(__tstate);
22430 if (PyErr_Occurred()) SWIG_fail;
22431 }
22432 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22433 return resultobj;
22434 fail:
22435 return NULL;
22436 }
22437
22438
22439 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22440 PyObject *resultobj = 0;
22441 wxDateTime result;
22442
22443 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22444 {
22445 PyThreadState* __tstate = wxPyBeginAllowThreads();
22446 result = wxDateTime::UNow();
22447 wxPyEndAllowThreads(__tstate);
22448 if (PyErr_Occurred()) SWIG_fail;
22449 }
22450 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22451 return resultobj;
22452 fail:
22453 return NULL;
22454 }
22455
22456
22457 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22458 PyObject *resultobj = 0;
22459 wxDateTime result;
22460
22461 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22462 {
22463 PyThreadState* __tstate = wxPyBeginAllowThreads();
22464 result = wxDateTime::Today();
22465 wxPyEndAllowThreads(__tstate);
22466 if (PyErr_Occurred()) SWIG_fail;
22467 }
22468 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22469 return resultobj;
22470 fail:
22471 return NULL;
22472 }
22473
22474
22475 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22476 PyObject *resultobj = 0;
22477 wxDateTime *result = 0 ;
22478
22479 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22480 {
22481 PyThreadState* __tstate = wxPyBeginAllowThreads();
22482 result = (wxDateTime *)new wxDateTime();
22483 wxPyEndAllowThreads(__tstate);
22484 if (PyErr_Occurred()) SWIG_fail;
22485 }
22486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22487 return resultobj;
22488 fail:
22489 return NULL;
22490 }
22491
22492
22493 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22494 PyObject *resultobj = 0;
22495 time_t arg1 ;
22496 wxDateTime *result = 0 ;
22497 unsigned int val1 ;
22498 int ecode1 = 0 ;
22499 PyObject * obj0 = 0 ;
22500 char * kwnames[] = {
22501 (char *) "timet", NULL
22502 };
22503
22504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22505 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22506 if (!SWIG_IsOK(ecode1)) {
22507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22508 }
22509 arg1 = static_cast< time_t >(val1);
22510 {
22511 PyThreadState* __tstate = wxPyBeginAllowThreads();
22512 result = (wxDateTime *)new wxDateTime(arg1);
22513 wxPyEndAllowThreads(__tstate);
22514 if (PyErr_Occurred()) SWIG_fail;
22515 }
22516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj = 0;
22525 double arg1 ;
22526 wxDateTime *result = 0 ;
22527 double val1 ;
22528 int ecode1 = 0 ;
22529 PyObject * obj0 = 0 ;
22530 char * kwnames[] = {
22531 (char *) "jdn", NULL
22532 };
22533
22534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22535 ecode1 = SWIG_AsVal_double(obj0, &val1);
22536 if (!SWIG_IsOK(ecode1)) {
22537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22538 }
22539 arg1 = static_cast< double >(val1);
22540 {
22541 PyThreadState* __tstate = wxPyBeginAllowThreads();
22542 result = (wxDateTime *)new wxDateTime(arg1);
22543 wxPyEndAllowThreads(__tstate);
22544 if (PyErr_Occurred()) SWIG_fail;
22545 }
22546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22547 return resultobj;
22548 fail:
22549 return NULL;
22550 }
22551
22552
22553 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22554 PyObject *resultobj = 0;
22555 int arg1 ;
22556 int arg2 = (int) 0 ;
22557 int arg3 = (int) 0 ;
22558 int arg4 = (int) 0 ;
22559 wxDateTime *result = 0 ;
22560 int val1 ;
22561 int ecode1 = 0 ;
22562 int val2 ;
22563 int ecode2 = 0 ;
22564 int val3 ;
22565 int ecode3 = 0 ;
22566 int val4 ;
22567 int ecode4 = 0 ;
22568 PyObject * obj0 = 0 ;
22569 PyObject * obj1 = 0 ;
22570 PyObject * obj2 = 0 ;
22571 PyObject * obj3 = 0 ;
22572 char * kwnames[] = {
22573 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22574 };
22575
22576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22577 ecode1 = SWIG_AsVal_int(obj0, &val1);
22578 if (!SWIG_IsOK(ecode1)) {
22579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22580 }
22581 arg1 = static_cast< int >(val1);
22582 if (obj1) {
22583 ecode2 = SWIG_AsVal_int(obj1, &val2);
22584 if (!SWIG_IsOK(ecode2)) {
22585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22586 }
22587 arg2 = static_cast< int >(val2);
22588 }
22589 if (obj2) {
22590 ecode3 = SWIG_AsVal_int(obj2, &val3);
22591 if (!SWIG_IsOK(ecode3)) {
22592 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22593 }
22594 arg3 = static_cast< int >(val3);
22595 }
22596 if (obj3) {
22597 ecode4 = SWIG_AsVal_int(obj3, &val4);
22598 if (!SWIG_IsOK(ecode4)) {
22599 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22600 }
22601 arg4 = static_cast< int >(val4);
22602 }
22603 {
22604 PyThreadState* __tstate = wxPyBeginAllowThreads();
22605 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22606 wxPyEndAllowThreads(__tstate);
22607 if (PyErr_Occurred()) SWIG_fail;
22608 }
22609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22610 return resultobj;
22611 fail:
22612 return NULL;
22613 }
22614
22615
22616 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22617 PyObject *resultobj = 0;
22618 int arg1 ;
22619 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22620 int arg3 = (int) wxDateTime::Inv_Year ;
22621 int arg4 = (int) 0 ;
22622 int arg5 = (int) 0 ;
22623 int arg6 = (int) 0 ;
22624 int arg7 = (int) 0 ;
22625 wxDateTime *result = 0 ;
22626 int val1 ;
22627 int ecode1 = 0 ;
22628 int val2 ;
22629 int ecode2 = 0 ;
22630 int val3 ;
22631 int ecode3 = 0 ;
22632 int val4 ;
22633 int ecode4 = 0 ;
22634 int val5 ;
22635 int ecode5 = 0 ;
22636 int val6 ;
22637 int ecode6 = 0 ;
22638 int val7 ;
22639 int ecode7 = 0 ;
22640 PyObject * obj0 = 0 ;
22641 PyObject * obj1 = 0 ;
22642 PyObject * obj2 = 0 ;
22643 PyObject * obj3 = 0 ;
22644 PyObject * obj4 = 0 ;
22645 PyObject * obj5 = 0 ;
22646 PyObject * obj6 = 0 ;
22647 char * kwnames[] = {
22648 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22649 };
22650
22651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22652 ecode1 = SWIG_AsVal_int(obj0, &val1);
22653 if (!SWIG_IsOK(ecode1)) {
22654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22655 }
22656 arg1 = static_cast< int >(val1);
22657 if (obj1) {
22658 ecode2 = SWIG_AsVal_int(obj1, &val2);
22659 if (!SWIG_IsOK(ecode2)) {
22660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22661 }
22662 arg2 = static_cast< wxDateTime::Month >(val2);
22663 }
22664 if (obj2) {
22665 ecode3 = SWIG_AsVal_int(obj2, &val3);
22666 if (!SWIG_IsOK(ecode3)) {
22667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22668 }
22669 arg3 = static_cast< int >(val3);
22670 }
22671 if (obj3) {
22672 ecode4 = SWIG_AsVal_int(obj3, &val4);
22673 if (!SWIG_IsOK(ecode4)) {
22674 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22675 }
22676 arg4 = static_cast< int >(val4);
22677 }
22678 if (obj4) {
22679 ecode5 = SWIG_AsVal_int(obj4, &val5);
22680 if (!SWIG_IsOK(ecode5)) {
22681 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22682 }
22683 arg5 = static_cast< int >(val5);
22684 }
22685 if (obj5) {
22686 ecode6 = SWIG_AsVal_int(obj5, &val6);
22687 if (!SWIG_IsOK(ecode6)) {
22688 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22689 }
22690 arg6 = static_cast< int >(val6);
22691 }
22692 if (obj6) {
22693 ecode7 = SWIG_AsVal_int(obj6, &val7);
22694 if (!SWIG_IsOK(ecode7)) {
22695 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22696 }
22697 arg7 = static_cast< int >(val7);
22698 }
22699 {
22700 PyThreadState* __tstate = wxPyBeginAllowThreads();
22701 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22702 wxPyEndAllowThreads(__tstate);
22703 if (PyErr_Occurred()) SWIG_fail;
22704 }
22705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22706 return resultobj;
22707 fail:
22708 return NULL;
22709 }
22710
22711
22712 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22713 PyObject *resultobj = 0;
22714 wxDateTime *arg1 = 0 ;
22715 wxDateTime *result = 0 ;
22716 void *argp1 = 0 ;
22717 int res1 = 0 ;
22718 PyObject * obj0 = 0 ;
22719 char * kwnames[] = {
22720 (char *) "date", NULL
22721 };
22722
22723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22724 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22725 if (!SWIG_IsOK(res1)) {
22726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22727 }
22728 if (!argp1) {
22729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22730 }
22731 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22732 {
22733 PyThreadState* __tstate = wxPyBeginAllowThreads();
22734 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22735 wxPyEndAllowThreads(__tstate);
22736 if (PyErr_Occurred()) SWIG_fail;
22737 }
22738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22739 return resultobj;
22740 fail:
22741 return NULL;
22742 }
22743
22744
22745 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22746 PyObject *resultobj = 0;
22747 wxDateTime *arg1 = (wxDateTime *) 0 ;
22748 void *argp1 = 0 ;
22749 int res1 = 0 ;
22750 PyObject *swig_obj[1] ;
22751
22752 if (!args) SWIG_fail;
22753 swig_obj[0] = args;
22754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22755 if (!SWIG_IsOK(res1)) {
22756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22757 }
22758 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22759 {
22760 PyThreadState* __tstate = wxPyBeginAllowThreads();
22761 delete arg1;
22762
22763 wxPyEndAllowThreads(__tstate);
22764 if (PyErr_Occurred()) SWIG_fail;
22765 }
22766 resultobj = SWIG_Py_Void();
22767 return resultobj;
22768 fail:
22769 return NULL;
22770 }
22771
22772
22773 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22774 PyObject *resultobj = 0;
22775 wxDateTime *arg1 = (wxDateTime *) 0 ;
22776 wxDateTime *result = 0 ;
22777 void *argp1 = 0 ;
22778 int res1 = 0 ;
22779 PyObject *swig_obj[1] ;
22780
22781 if (!args) SWIG_fail;
22782 swig_obj[0] = args;
22783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22784 if (!SWIG_IsOK(res1)) {
22785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22786 }
22787 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22788 {
22789 PyThreadState* __tstate = wxPyBeginAllowThreads();
22790 {
22791 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22792 result = (wxDateTime *) &_result_ref;
22793 }
22794 wxPyEndAllowThreads(__tstate);
22795 if (PyErr_Occurred()) SWIG_fail;
22796 }
22797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22798 return resultobj;
22799 fail:
22800 return NULL;
22801 }
22802
22803
22804 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22805 PyObject *resultobj = 0;
22806 wxDateTime *arg1 = (wxDateTime *) 0 ;
22807 time_t arg2 ;
22808 wxDateTime *result = 0 ;
22809 void *argp1 = 0 ;
22810 int res1 = 0 ;
22811 unsigned int val2 ;
22812 int ecode2 = 0 ;
22813 PyObject * obj0 = 0 ;
22814 PyObject * obj1 = 0 ;
22815 char * kwnames[] = {
22816 (char *) "self",(char *) "timet", NULL
22817 };
22818
22819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22821 if (!SWIG_IsOK(res1)) {
22822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22823 }
22824 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22825 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22826 if (!SWIG_IsOK(ecode2)) {
22827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22828 }
22829 arg2 = static_cast< time_t >(val2);
22830 {
22831 PyThreadState* __tstate = wxPyBeginAllowThreads();
22832 {
22833 wxDateTime &_result_ref = (arg1)->Set(arg2);
22834 result = (wxDateTime *) &_result_ref;
22835 }
22836 wxPyEndAllowThreads(__tstate);
22837 if (PyErr_Occurred()) SWIG_fail;
22838 }
22839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22840 return resultobj;
22841 fail:
22842 return NULL;
22843 }
22844
22845
22846 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22847 PyObject *resultobj = 0;
22848 wxDateTime *arg1 = (wxDateTime *) 0 ;
22849 double arg2 ;
22850 wxDateTime *result = 0 ;
22851 void *argp1 = 0 ;
22852 int res1 = 0 ;
22853 double val2 ;
22854 int ecode2 = 0 ;
22855 PyObject * obj0 = 0 ;
22856 PyObject * obj1 = 0 ;
22857 char * kwnames[] = {
22858 (char *) "self",(char *) "jdn", NULL
22859 };
22860
22861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22863 if (!SWIG_IsOK(res1)) {
22864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22865 }
22866 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22867 ecode2 = SWIG_AsVal_double(obj1, &val2);
22868 if (!SWIG_IsOK(ecode2)) {
22869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22870 }
22871 arg2 = static_cast< double >(val2);
22872 {
22873 PyThreadState* __tstate = wxPyBeginAllowThreads();
22874 {
22875 wxDateTime &_result_ref = (arg1)->Set(arg2);
22876 result = (wxDateTime *) &_result_ref;
22877 }
22878 wxPyEndAllowThreads(__tstate);
22879 if (PyErr_Occurred()) SWIG_fail;
22880 }
22881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22882 return resultobj;
22883 fail:
22884 return NULL;
22885 }
22886
22887
22888 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22889 PyObject *resultobj = 0;
22890 wxDateTime *arg1 = (wxDateTime *) 0 ;
22891 int arg2 ;
22892 int arg3 = (int) 0 ;
22893 int arg4 = (int) 0 ;
22894 int arg5 = (int) 0 ;
22895 wxDateTime *result = 0 ;
22896 void *argp1 = 0 ;
22897 int res1 = 0 ;
22898 int val2 ;
22899 int ecode2 = 0 ;
22900 int val3 ;
22901 int ecode3 = 0 ;
22902 int val4 ;
22903 int ecode4 = 0 ;
22904 int val5 ;
22905 int ecode5 = 0 ;
22906 PyObject * obj0 = 0 ;
22907 PyObject * obj1 = 0 ;
22908 PyObject * obj2 = 0 ;
22909 PyObject * obj3 = 0 ;
22910 PyObject * obj4 = 0 ;
22911 char * kwnames[] = {
22912 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22913 };
22914
22915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22917 if (!SWIG_IsOK(res1)) {
22918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22919 }
22920 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22921 ecode2 = SWIG_AsVal_int(obj1, &val2);
22922 if (!SWIG_IsOK(ecode2)) {
22923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22924 }
22925 arg2 = static_cast< int >(val2);
22926 if (obj2) {
22927 ecode3 = SWIG_AsVal_int(obj2, &val3);
22928 if (!SWIG_IsOK(ecode3)) {
22929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22930 }
22931 arg3 = static_cast< int >(val3);
22932 }
22933 if (obj3) {
22934 ecode4 = SWIG_AsVal_int(obj3, &val4);
22935 if (!SWIG_IsOK(ecode4)) {
22936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22937 }
22938 arg4 = static_cast< int >(val4);
22939 }
22940 if (obj4) {
22941 ecode5 = SWIG_AsVal_int(obj4, &val5);
22942 if (!SWIG_IsOK(ecode5)) {
22943 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22944 }
22945 arg5 = static_cast< int >(val5);
22946 }
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 {
22950 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22951 result = (wxDateTime *) &_result_ref;
22952 }
22953 wxPyEndAllowThreads(__tstate);
22954 if (PyErr_Occurred()) SWIG_fail;
22955 }
22956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22957 return resultobj;
22958 fail:
22959 return NULL;
22960 }
22961
22962
22963 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22964 PyObject *resultobj = 0;
22965 wxDateTime *arg1 = (wxDateTime *) 0 ;
22966 int arg2 ;
22967 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22968 int arg4 = (int) wxDateTime::Inv_Year ;
22969 int arg5 = (int) 0 ;
22970 int arg6 = (int) 0 ;
22971 int arg7 = (int) 0 ;
22972 int arg8 = (int) 0 ;
22973 wxDateTime *result = 0 ;
22974 void *argp1 = 0 ;
22975 int res1 = 0 ;
22976 int val2 ;
22977 int ecode2 = 0 ;
22978 int val3 ;
22979 int ecode3 = 0 ;
22980 int val4 ;
22981 int ecode4 = 0 ;
22982 int val5 ;
22983 int ecode5 = 0 ;
22984 int val6 ;
22985 int ecode6 = 0 ;
22986 int val7 ;
22987 int ecode7 = 0 ;
22988 int val8 ;
22989 int ecode8 = 0 ;
22990 PyObject * obj0 = 0 ;
22991 PyObject * obj1 = 0 ;
22992 PyObject * obj2 = 0 ;
22993 PyObject * obj3 = 0 ;
22994 PyObject * obj4 = 0 ;
22995 PyObject * obj5 = 0 ;
22996 PyObject * obj6 = 0 ;
22997 PyObject * obj7 = 0 ;
22998 char * kwnames[] = {
22999 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23000 };
23001
23002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23004 if (!SWIG_IsOK(res1)) {
23005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23006 }
23007 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23008 ecode2 = SWIG_AsVal_int(obj1, &val2);
23009 if (!SWIG_IsOK(ecode2)) {
23010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23011 }
23012 arg2 = static_cast< int >(val2);
23013 if (obj2) {
23014 ecode3 = SWIG_AsVal_int(obj2, &val3);
23015 if (!SWIG_IsOK(ecode3)) {
23016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23017 }
23018 arg3 = static_cast< wxDateTime::Month >(val3);
23019 }
23020 if (obj3) {
23021 ecode4 = SWIG_AsVal_int(obj3, &val4);
23022 if (!SWIG_IsOK(ecode4)) {
23023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23024 }
23025 arg4 = static_cast< int >(val4);
23026 }
23027 if (obj4) {
23028 ecode5 = SWIG_AsVal_int(obj4, &val5);
23029 if (!SWIG_IsOK(ecode5)) {
23030 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23031 }
23032 arg5 = static_cast< int >(val5);
23033 }
23034 if (obj5) {
23035 ecode6 = SWIG_AsVal_int(obj5, &val6);
23036 if (!SWIG_IsOK(ecode6)) {
23037 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23038 }
23039 arg6 = static_cast< int >(val6);
23040 }
23041 if (obj6) {
23042 ecode7 = SWIG_AsVal_int(obj6, &val7);
23043 if (!SWIG_IsOK(ecode7)) {
23044 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23045 }
23046 arg7 = static_cast< int >(val7);
23047 }
23048 if (obj7) {
23049 ecode8 = SWIG_AsVal_int(obj7, &val8);
23050 if (!SWIG_IsOK(ecode8)) {
23051 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23052 }
23053 arg8 = static_cast< int >(val8);
23054 }
23055 {
23056 PyThreadState* __tstate = wxPyBeginAllowThreads();
23057 {
23058 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23059 result = (wxDateTime *) &_result_ref;
23060 }
23061 wxPyEndAllowThreads(__tstate);
23062 if (PyErr_Occurred()) SWIG_fail;
23063 }
23064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23065 return resultobj;
23066 fail:
23067 return NULL;
23068 }
23069
23070
23071 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23072 PyObject *resultobj = 0;
23073 wxDateTime *arg1 = (wxDateTime *) 0 ;
23074 wxDateTime *result = 0 ;
23075 void *argp1 = 0 ;
23076 int res1 = 0 ;
23077 PyObject *swig_obj[1] ;
23078
23079 if (!args) SWIG_fail;
23080 swig_obj[0] = args;
23081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23082 if (!SWIG_IsOK(res1)) {
23083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23084 }
23085 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23086 {
23087 PyThreadState* __tstate = wxPyBeginAllowThreads();
23088 {
23089 wxDateTime &_result_ref = (arg1)->ResetTime();
23090 result = (wxDateTime *) &_result_ref;
23091 }
23092 wxPyEndAllowThreads(__tstate);
23093 if (PyErr_Occurred()) SWIG_fail;
23094 }
23095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23096 return resultobj;
23097 fail:
23098 return NULL;
23099 }
23100
23101
23102 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23103 PyObject *resultobj = 0;
23104 wxDateTime *arg1 = (wxDateTime *) 0 ;
23105 int arg2 ;
23106 wxDateTime *result = 0 ;
23107 void *argp1 = 0 ;
23108 int res1 = 0 ;
23109 int val2 ;
23110 int ecode2 = 0 ;
23111 PyObject * obj0 = 0 ;
23112 PyObject * obj1 = 0 ;
23113 char * kwnames[] = {
23114 (char *) "self",(char *) "year", NULL
23115 };
23116
23117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23121 }
23122 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23123 ecode2 = SWIG_AsVal_int(obj1, &val2);
23124 if (!SWIG_IsOK(ecode2)) {
23125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23126 }
23127 arg2 = static_cast< int >(val2);
23128 {
23129 PyThreadState* __tstate = wxPyBeginAllowThreads();
23130 {
23131 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23132 result = (wxDateTime *) &_result_ref;
23133 }
23134 wxPyEndAllowThreads(__tstate);
23135 if (PyErr_Occurred()) SWIG_fail;
23136 }
23137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23145 PyObject *resultobj = 0;
23146 wxDateTime *arg1 = (wxDateTime *) 0 ;
23147 wxDateTime::Month arg2 ;
23148 wxDateTime *result = 0 ;
23149 void *argp1 = 0 ;
23150 int res1 = 0 ;
23151 int val2 ;
23152 int ecode2 = 0 ;
23153 PyObject * obj0 = 0 ;
23154 PyObject * obj1 = 0 ;
23155 char * kwnames[] = {
23156 (char *) "self",(char *) "month", NULL
23157 };
23158
23159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23161 if (!SWIG_IsOK(res1)) {
23162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23163 }
23164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23165 ecode2 = SWIG_AsVal_int(obj1, &val2);
23166 if (!SWIG_IsOK(ecode2)) {
23167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23168 }
23169 arg2 = static_cast< wxDateTime::Month >(val2);
23170 {
23171 PyThreadState* __tstate = wxPyBeginAllowThreads();
23172 {
23173 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23174 result = (wxDateTime *) &_result_ref;
23175 }
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23180 return resultobj;
23181 fail:
23182 return NULL;
23183 }
23184
23185
23186 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23187 PyObject *resultobj = 0;
23188 wxDateTime *arg1 = (wxDateTime *) 0 ;
23189 int arg2 ;
23190 wxDateTime *result = 0 ;
23191 void *argp1 = 0 ;
23192 int res1 = 0 ;
23193 int val2 ;
23194 int ecode2 = 0 ;
23195 PyObject * obj0 = 0 ;
23196 PyObject * obj1 = 0 ;
23197 char * kwnames[] = {
23198 (char *) "self",(char *) "day", NULL
23199 };
23200
23201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23203 if (!SWIG_IsOK(res1)) {
23204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23205 }
23206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23207 ecode2 = SWIG_AsVal_int(obj1, &val2);
23208 if (!SWIG_IsOK(ecode2)) {
23209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23210 }
23211 arg2 = static_cast< int >(val2);
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 {
23215 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23216 result = (wxDateTime *) &_result_ref;
23217 }
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23229 PyObject *resultobj = 0;
23230 wxDateTime *arg1 = (wxDateTime *) 0 ;
23231 int arg2 ;
23232 wxDateTime *result = 0 ;
23233 void *argp1 = 0 ;
23234 int res1 = 0 ;
23235 int val2 ;
23236 int ecode2 = 0 ;
23237 PyObject * obj0 = 0 ;
23238 PyObject * obj1 = 0 ;
23239 char * kwnames[] = {
23240 (char *) "self",(char *) "hour", NULL
23241 };
23242
23243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23245 if (!SWIG_IsOK(res1)) {
23246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23247 }
23248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23249 ecode2 = SWIG_AsVal_int(obj1, &val2);
23250 if (!SWIG_IsOK(ecode2)) {
23251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23252 }
23253 arg2 = static_cast< int >(val2);
23254 {
23255 PyThreadState* __tstate = wxPyBeginAllowThreads();
23256 {
23257 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23258 result = (wxDateTime *) &_result_ref;
23259 }
23260 wxPyEndAllowThreads(__tstate);
23261 if (PyErr_Occurred()) SWIG_fail;
23262 }
23263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23264 return resultobj;
23265 fail:
23266 return NULL;
23267 }
23268
23269
23270 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23271 PyObject *resultobj = 0;
23272 wxDateTime *arg1 = (wxDateTime *) 0 ;
23273 int arg2 ;
23274 wxDateTime *result = 0 ;
23275 void *argp1 = 0 ;
23276 int res1 = 0 ;
23277 int val2 ;
23278 int ecode2 = 0 ;
23279 PyObject * obj0 = 0 ;
23280 PyObject * obj1 = 0 ;
23281 char * kwnames[] = {
23282 (char *) "self",(char *) "minute", NULL
23283 };
23284
23285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23287 if (!SWIG_IsOK(res1)) {
23288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23289 }
23290 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23291 ecode2 = SWIG_AsVal_int(obj1, &val2);
23292 if (!SWIG_IsOK(ecode2)) {
23293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23294 }
23295 arg2 = static_cast< int >(val2);
23296 {
23297 PyThreadState* __tstate = wxPyBeginAllowThreads();
23298 {
23299 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23300 result = (wxDateTime *) &_result_ref;
23301 }
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj = 0;
23314 wxDateTime *arg1 = (wxDateTime *) 0 ;
23315 int arg2 ;
23316 wxDateTime *result = 0 ;
23317 void *argp1 = 0 ;
23318 int res1 = 0 ;
23319 int val2 ;
23320 int ecode2 = 0 ;
23321 PyObject * obj0 = 0 ;
23322 PyObject * obj1 = 0 ;
23323 char * kwnames[] = {
23324 (char *) "self",(char *) "second", NULL
23325 };
23326
23327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23329 if (!SWIG_IsOK(res1)) {
23330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23331 }
23332 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23333 ecode2 = SWIG_AsVal_int(obj1, &val2);
23334 if (!SWIG_IsOK(ecode2)) {
23335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23336 }
23337 arg2 = static_cast< int >(val2);
23338 {
23339 PyThreadState* __tstate = wxPyBeginAllowThreads();
23340 {
23341 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23342 result = (wxDateTime *) &_result_ref;
23343 }
23344 wxPyEndAllowThreads(__tstate);
23345 if (PyErr_Occurred()) SWIG_fail;
23346 }
23347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23348 return resultobj;
23349 fail:
23350 return NULL;
23351 }
23352
23353
23354 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23355 PyObject *resultobj = 0;
23356 wxDateTime *arg1 = (wxDateTime *) 0 ;
23357 int arg2 ;
23358 wxDateTime *result = 0 ;
23359 void *argp1 = 0 ;
23360 int res1 = 0 ;
23361 int val2 ;
23362 int ecode2 = 0 ;
23363 PyObject * obj0 = 0 ;
23364 PyObject * obj1 = 0 ;
23365 char * kwnames[] = {
23366 (char *) "self",(char *) "millisecond", NULL
23367 };
23368
23369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23371 if (!SWIG_IsOK(res1)) {
23372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23373 }
23374 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23375 ecode2 = SWIG_AsVal_int(obj1, &val2);
23376 if (!SWIG_IsOK(ecode2)) {
23377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23378 }
23379 arg2 = static_cast< int >(val2);
23380 {
23381 PyThreadState* __tstate = wxPyBeginAllowThreads();
23382 {
23383 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23384 result = (wxDateTime *) &_result_ref;
23385 }
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23390 return resultobj;
23391 fail:
23392 return NULL;
23393 }
23394
23395
23396 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23397 PyObject *resultobj = 0;
23398 wxDateTime *arg1 = (wxDateTime *) 0 ;
23399 wxDateTime::WeekDay arg2 ;
23400 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23401 wxDateTime *result = 0 ;
23402 void *argp1 = 0 ;
23403 int res1 = 0 ;
23404 int val2 ;
23405 int ecode2 = 0 ;
23406 int val3 ;
23407 int ecode3 = 0 ;
23408 PyObject * obj0 = 0 ;
23409 PyObject * obj1 = 0 ;
23410 PyObject * obj2 = 0 ;
23411 char * kwnames[] = {
23412 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23413 };
23414
23415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23417 if (!SWIG_IsOK(res1)) {
23418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23419 }
23420 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23421 ecode2 = SWIG_AsVal_int(obj1, &val2);
23422 if (!SWIG_IsOK(ecode2)) {
23423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23424 }
23425 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23426 if (obj2) {
23427 ecode3 = SWIG_AsVal_int(obj2, &val3);
23428 if (!SWIG_IsOK(ecode3)) {
23429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23430 }
23431 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23432 }
23433 {
23434 PyThreadState* __tstate = wxPyBeginAllowThreads();
23435 {
23436 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23437 result = (wxDateTime *) &_result_ref;
23438 }
23439 wxPyEndAllowThreads(__tstate);
23440 if (PyErr_Occurred()) SWIG_fail;
23441 }
23442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23450 PyObject *resultobj = 0;
23451 wxDateTime *arg1 = (wxDateTime *) 0 ;
23452 wxDateTime::WeekDay arg2 ;
23453 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23454 wxDateTime result;
23455 void *argp1 = 0 ;
23456 int res1 = 0 ;
23457 int val2 ;
23458 int ecode2 = 0 ;
23459 int val3 ;
23460 int ecode3 = 0 ;
23461 PyObject * obj0 = 0 ;
23462 PyObject * obj1 = 0 ;
23463 PyObject * obj2 = 0 ;
23464 char * kwnames[] = {
23465 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23466 };
23467
23468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23470 if (!SWIG_IsOK(res1)) {
23471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23472 }
23473 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23474 ecode2 = SWIG_AsVal_int(obj1, &val2);
23475 if (!SWIG_IsOK(ecode2)) {
23476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23477 }
23478 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23479 if (obj2) {
23480 ecode3 = SWIG_AsVal_int(obj2, &val3);
23481 if (!SWIG_IsOK(ecode3)) {
23482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23483 }
23484 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23485 }
23486 {
23487 PyThreadState* __tstate = wxPyBeginAllowThreads();
23488 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23489 wxPyEndAllowThreads(__tstate);
23490 if (PyErr_Occurred()) SWIG_fail;
23491 }
23492 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23493 return resultobj;
23494 fail:
23495 return NULL;
23496 }
23497
23498
23499 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23500 PyObject *resultobj = 0;
23501 wxDateTime *arg1 = (wxDateTime *) 0 ;
23502 wxDateTime::WeekDay arg2 ;
23503 wxDateTime *result = 0 ;
23504 void *argp1 = 0 ;
23505 int res1 = 0 ;
23506 int val2 ;
23507 int ecode2 = 0 ;
23508 PyObject * obj0 = 0 ;
23509 PyObject * obj1 = 0 ;
23510 char * kwnames[] = {
23511 (char *) "self",(char *) "weekday", NULL
23512 };
23513
23514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23516 if (!SWIG_IsOK(res1)) {
23517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23518 }
23519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23520 ecode2 = SWIG_AsVal_int(obj1, &val2);
23521 if (!SWIG_IsOK(ecode2)) {
23522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23523 }
23524 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 {
23528 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23529 result = (wxDateTime *) &_result_ref;
23530 }
23531 wxPyEndAllowThreads(__tstate);
23532 if (PyErr_Occurred()) SWIG_fail;
23533 }
23534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23542 PyObject *resultobj = 0;
23543 wxDateTime *arg1 = (wxDateTime *) 0 ;
23544 wxDateTime::WeekDay arg2 ;
23545 wxDateTime result;
23546 void *argp1 = 0 ;
23547 int res1 = 0 ;
23548 int val2 ;
23549 int ecode2 = 0 ;
23550 PyObject * obj0 = 0 ;
23551 PyObject * obj1 = 0 ;
23552 char * kwnames[] = {
23553 (char *) "self",(char *) "weekday", NULL
23554 };
23555
23556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23558 if (!SWIG_IsOK(res1)) {
23559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23560 }
23561 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23562 ecode2 = SWIG_AsVal_int(obj1, &val2);
23563 if (!SWIG_IsOK(ecode2)) {
23564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23565 }
23566 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23567 {
23568 PyThreadState* __tstate = wxPyBeginAllowThreads();
23569 result = (arg1)->GetNextWeekDay(arg2);
23570 wxPyEndAllowThreads(__tstate);
23571 if (PyErr_Occurred()) SWIG_fail;
23572 }
23573 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23581 PyObject *resultobj = 0;
23582 wxDateTime *arg1 = (wxDateTime *) 0 ;
23583 wxDateTime::WeekDay arg2 ;
23584 wxDateTime *result = 0 ;
23585 void *argp1 = 0 ;
23586 int res1 = 0 ;
23587 int val2 ;
23588 int ecode2 = 0 ;
23589 PyObject * obj0 = 0 ;
23590 PyObject * obj1 = 0 ;
23591 char * kwnames[] = {
23592 (char *) "self",(char *) "weekday", NULL
23593 };
23594
23595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23597 if (!SWIG_IsOK(res1)) {
23598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23599 }
23600 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23601 ecode2 = SWIG_AsVal_int(obj1, &val2);
23602 if (!SWIG_IsOK(ecode2)) {
23603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23604 }
23605 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 {
23609 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23610 result = (wxDateTime *) &_result_ref;
23611 }
23612 wxPyEndAllowThreads(__tstate);
23613 if (PyErr_Occurred()) SWIG_fail;
23614 }
23615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23623 PyObject *resultobj = 0;
23624 wxDateTime *arg1 = (wxDateTime *) 0 ;
23625 wxDateTime::WeekDay arg2 ;
23626 wxDateTime result;
23627 void *argp1 = 0 ;
23628 int res1 = 0 ;
23629 int val2 ;
23630 int ecode2 = 0 ;
23631 PyObject * obj0 = 0 ;
23632 PyObject * obj1 = 0 ;
23633 char * kwnames[] = {
23634 (char *) "self",(char *) "weekday", NULL
23635 };
23636
23637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23639 if (!SWIG_IsOK(res1)) {
23640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23641 }
23642 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23643 ecode2 = SWIG_AsVal_int(obj1, &val2);
23644 if (!SWIG_IsOK(ecode2)) {
23645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23646 }
23647 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 result = (arg1)->GetPrevWeekDay(arg2);
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23655 return resultobj;
23656 fail:
23657 return NULL;
23658 }
23659
23660
23661 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23662 PyObject *resultobj = 0;
23663 wxDateTime *arg1 = (wxDateTime *) 0 ;
23664 wxDateTime::WeekDay arg2 ;
23665 int arg3 = (int) 1 ;
23666 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23667 int arg5 = (int) wxDateTime::Inv_Year ;
23668 bool result;
23669 void *argp1 = 0 ;
23670 int res1 = 0 ;
23671 int val2 ;
23672 int ecode2 = 0 ;
23673 int val3 ;
23674 int ecode3 = 0 ;
23675 int val4 ;
23676 int ecode4 = 0 ;
23677 int val5 ;
23678 int ecode5 = 0 ;
23679 PyObject * obj0 = 0 ;
23680 PyObject * obj1 = 0 ;
23681 PyObject * obj2 = 0 ;
23682 PyObject * obj3 = 0 ;
23683 PyObject * obj4 = 0 ;
23684 char * kwnames[] = {
23685 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23686 };
23687
23688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23690 if (!SWIG_IsOK(res1)) {
23691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23692 }
23693 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23694 ecode2 = SWIG_AsVal_int(obj1, &val2);
23695 if (!SWIG_IsOK(ecode2)) {
23696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23697 }
23698 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23699 if (obj2) {
23700 ecode3 = SWIG_AsVal_int(obj2, &val3);
23701 if (!SWIG_IsOK(ecode3)) {
23702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23703 }
23704 arg3 = static_cast< int >(val3);
23705 }
23706 if (obj3) {
23707 ecode4 = SWIG_AsVal_int(obj3, &val4);
23708 if (!SWIG_IsOK(ecode4)) {
23709 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23710 }
23711 arg4 = static_cast< wxDateTime::Month >(val4);
23712 }
23713 if (obj4) {
23714 ecode5 = SWIG_AsVal_int(obj4, &val5);
23715 if (!SWIG_IsOK(ecode5)) {
23716 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23717 }
23718 arg5 = static_cast< int >(val5);
23719 }
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 {
23727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23728 }
23729 return resultobj;
23730 fail:
23731 return NULL;
23732 }
23733
23734
23735 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23736 PyObject *resultobj = 0;
23737 wxDateTime *arg1 = (wxDateTime *) 0 ;
23738 wxDateTime::WeekDay arg2 ;
23739 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23740 int arg4 = (int) wxDateTime::Inv_Year ;
23741 bool result;
23742 void *argp1 = 0 ;
23743 int res1 = 0 ;
23744 int val2 ;
23745 int ecode2 = 0 ;
23746 int val3 ;
23747 int ecode3 = 0 ;
23748 int val4 ;
23749 int ecode4 = 0 ;
23750 PyObject * obj0 = 0 ;
23751 PyObject * obj1 = 0 ;
23752 PyObject * obj2 = 0 ;
23753 PyObject * obj3 = 0 ;
23754 char * kwnames[] = {
23755 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23756 };
23757
23758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23760 if (!SWIG_IsOK(res1)) {
23761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23762 }
23763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23764 ecode2 = SWIG_AsVal_int(obj1, &val2);
23765 if (!SWIG_IsOK(ecode2)) {
23766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23767 }
23768 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23769 if (obj2) {
23770 ecode3 = SWIG_AsVal_int(obj2, &val3);
23771 if (!SWIG_IsOK(ecode3)) {
23772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23773 }
23774 arg3 = static_cast< wxDateTime::Month >(val3);
23775 }
23776 if (obj3) {
23777 ecode4 = SWIG_AsVal_int(obj3, &val4);
23778 if (!SWIG_IsOK(ecode4)) {
23779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23780 }
23781 arg4 = static_cast< int >(val4);
23782 }
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 {
23790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23791 }
23792 return resultobj;
23793 fail:
23794 return NULL;
23795 }
23796
23797
23798 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23799 PyObject *resultobj = 0;
23800 wxDateTime *arg1 = (wxDateTime *) 0 ;
23801 wxDateTime::WeekDay arg2 ;
23802 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23803 int arg4 = (int) wxDateTime::Inv_Year ;
23804 wxDateTime result;
23805 void *argp1 = 0 ;
23806 int res1 = 0 ;
23807 int val2 ;
23808 int ecode2 = 0 ;
23809 int val3 ;
23810 int ecode3 = 0 ;
23811 int val4 ;
23812 int ecode4 = 0 ;
23813 PyObject * obj0 = 0 ;
23814 PyObject * obj1 = 0 ;
23815 PyObject * obj2 = 0 ;
23816 PyObject * obj3 = 0 ;
23817 char * kwnames[] = {
23818 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23819 };
23820
23821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23823 if (!SWIG_IsOK(res1)) {
23824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23825 }
23826 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23827 ecode2 = SWIG_AsVal_int(obj1, &val2);
23828 if (!SWIG_IsOK(ecode2)) {
23829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23830 }
23831 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23832 if (obj2) {
23833 ecode3 = SWIG_AsVal_int(obj2, &val3);
23834 if (!SWIG_IsOK(ecode3)) {
23835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23836 }
23837 arg3 = static_cast< wxDateTime::Month >(val3);
23838 }
23839 if (obj3) {
23840 ecode4 = SWIG_AsVal_int(obj3, &val4);
23841 if (!SWIG_IsOK(ecode4)) {
23842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23843 }
23844 arg4 = static_cast< int >(val4);
23845 }
23846 {
23847 PyThreadState* __tstate = wxPyBeginAllowThreads();
23848 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23849 wxPyEndAllowThreads(__tstate);
23850 if (PyErr_Occurred()) SWIG_fail;
23851 }
23852 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23853 return resultobj;
23854 fail:
23855 return NULL;
23856 }
23857
23858
23859 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23860 PyObject *resultobj = 0;
23861 wxDateTime *arg1 = (wxDateTime *) 0 ;
23862 int arg2 ;
23863 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23864 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23865 bool result;
23866 void *argp1 = 0 ;
23867 int res1 = 0 ;
23868 int val2 ;
23869 int ecode2 = 0 ;
23870 int val3 ;
23871 int ecode3 = 0 ;
23872 int val4 ;
23873 int ecode4 = 0 ;
23874 PyObject * obj0 = 0 ;
23875 PyObject * obj1 = 0 ;
23876 PyObject * obj2 = 0 ;
23877 PyObject * obj3 = 0 ;
23878 char * kwnames[] = {
23879 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23880 };
23881
23882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23884 if (!SWIG_IsOK(res1)) {
23885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23886 }
23887 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23888 ecode2 = SWIG_AsVal_int(obj1, &val2);
23889 if (!SWIG_IsOK(ecode2)) {
23890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23891 }
23892 arg2 = static_cast< int >(val2);
23893 if (obj2) {
23894 ecode3 = SWIG_AsVal_int(obj2, &val3);
23895 if (!SWIG_IsOK(ecode3)) {
23896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23897 }
23898 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23899 }
23900 if (obj3) {
23901 ecode4 = SWIG_AsVal_int(obj3, &val4);
23902 if (!SWIG_IsOK(ecode4)) {
23903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23904 }
23905 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23906 }
23907 {
23908 PyThreadState* __tstate = wxPyBeginAllowThreads();
23909 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23910 wxPyEndAllowThreads(__tstate);
23911 if (PyErr_Occurred()) SWIG_fail;
23912 }
23913 {
23914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23915 }
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23923 PyObject *resultobj = 0;
23924 wxDateTime *arg1 = (wxDateTime *) 0 ;
23925 int arg2 ;
23926 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23927 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23928 wxDateTime result;
23929 void *argp1 = 0 ;
23930 int res1 = 0 ;
23931 int val2 ;
23932 int ecode2 = 0 ;
23933 int val3 ;
23934 int ecode3 = 0 ;
23935 int val4 ;
23936 int ecode4 = 0 ;
23937 PyObject * obj0 = 0 ;
23938 PyObject * obj1 = 0 ;
23939 PyObject * obj2 = 0 ;
23940 PyObject * obj3 = 0 ;
23941 char * kwnames[] = {
23942 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23943 };
23944
23945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23947 if (!SWIG_IsOK(res1)) {
23948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23949 }
23950 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23951 ecode2 = SWIG_AsVal_int(obj1, &val2);
23952 if (!SWIG_IsOK(ecode2)) {
23953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23954 }
23955 arg2 = static_cast< int >(val2);
23956 if (obj2) {
23957 ecode3 = SWIG_AsVal_int(obj2, &val3);
23958 if (!SWIG_IsOK(ecode3)) {
23959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23960 }
23961 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23962 }
23963 if (obj3) {
23964 ecode4 = SWIG_AsVal_int(obj3, &val4);
23965 if (!SWIG_IsOK(ecode4)) {
23966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23967 }
23968 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23969 }
23970 {
23971 PyThreadState* __tstate = wxPyBeginAllowThreads();
23972 result = (arg1)->GetWeek(arg2,arg3,arg4);
23973 wxPyEndAllowThreads(__tstate);
23974 if (PyErr_Occurred()) SWIG_fail;
23975 }
23976 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23977 return resultobj;
23978 fail:
23979 return NULL;
23980 }
23981
23982
23983 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23984 PyObject *resultobj = 0;
23985 int arg1 ;
23986 int arg2 ;
23987 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23988 wxDateTime result;
23989 int val1 ;
23990 int ecode1 = 0 ;
23991 int val2 ;
23992 int ecode2 = 0 ;
23993 int val3 ;
23994 int ecode3 = 0 ;
23995 PyObject * obj0 = 0 ;
23996 PyObject * obj1 = 0 ;
23997 PyObject * obj2 = 0 ;
23998 char * kwnames[] = {
23999 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24000 };
24001
24002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24003 ecode1 = SWIG_AsVal_int(obj0, &val1);
24004 if (!SWIG_IsOK(ecode1)) {
24005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24006 }
24007 arg1 = static_cast< int >(val1);
24008 ecode2 = SWIG_AsVal_int(obj1, &val2);
24009 if (!SWIG_IsOK(ecode2)) {
24010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24011 }
24012 arg2 = static_cast< int >(val2);
24013 if (obj2) {
24014 ecode3 = SWIG_AsVal_int(obj2, &val3);
24015 if (!SWIG_IsOK(ecode3)) {
24016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24017 }
24018 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24019 }
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24034 PyObject *resultobj = 0;
24035 wxDateTime *arg1 = (wxDateTime *) 0 ;
24036 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24037 int arg3 = (int) wxDateTime::Inv_Year ;
24038 wxDateTime *result = 0 ;
24039 void *argp1 = 0 ;
24040 int res1 = 0 ;
24041 int val2 ;
24042 int ecode2 = 0 ;
24043 int val3 ;
24044 int ecode3 = 0 ;
24045 PyObject * obj0 = 0 ;
24046 PyObject * obj1 = 0 ;
24047 PyObject * obj2 = 0 ;
24048 char * kwnames[] = {
24049 (char *) "self",(char *) "month",(char *) "year", NULL
24050 };
24051
24052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24054 if (!SWIG_IsOK(res1)) {
24055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24056 }
24057 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24058 if (obj1) {
24059 ecode2 = SWIG_AsVal_int(obj1, &val2);
24060 if (!SWIG_IsOK(ecode2)) {
24061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24062 }
24063 arg2 = static_cast< wxDateTime::Month >(val2);
24064 }
24065 if (obj2) {
24066 ecode3 = SWIG_AsVal_int(obj2, &val3);
24067 if (!SWIG_IsOK(ecode3)) {
24068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24069 }
24070 arg3 = static_cast< int >(val3);
24071 }
24072 {
24073 PyThreadState* __tstate = wxPyBeginAllowThreads();
24074 {
24075 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24076 result = (wxDateTime *) &_result_ref;
24077 }
24078 wxPyEndAllowThreads(__tstate);
24079 if (PyErr_Occurred()) SWIG_fail;
24080 }
24081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24082 return resultobj;
24083 fail:
24084 return NULL;
24085 }
24086
24087
24088 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24089 PyObject *resultobj = 0;
24090 wxDateTime *arg1 = (wxDateTime *) 0 ;
24091 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24092 int arg3 = (int) wxDateTime::Inv_Year ;
24093 wxDateTime result;
24094 void *argp1 = 0 ;
24095 int res1 = 0 ;
24096 int val2 ;
24097 int ecode2 = 0 ;
24098 int val3 ;
24099 int ecode3 = 0 ;
24100 PyObject * obj0 = 0 ;
24101 PyObject * obj1 = 0 ;
24102 PyObject * obj2 = 0 ;
24103 char * kwnames[] = {
24104 (char *) "self",(char *) "month",(char *) "year", NULL
24105 };
24106
24107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24109 if (!SWIG_IsOK(res1)) {
24110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24111 }
24112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24113 if (obj1) {
24114 ecode2 = SWIG_AsVal_int(obj1, &val2);
24115 if (!SWIG_IsOK(ecode2)) {
24116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24117 }
24118 arg2 = static_cast< wxDateTime::Month >(val2);
24119 }
24120 if (obj2) {
24121 ecode3 = SWIG_AsVal_int(obj2, &val3);
24122 if (!SWIG_IsOK(ecode3)) {
24123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24124 }
24125 arg3 = static_cast< int >(val3);
24126 }
24127 {
24128 PyThreadState* __tstate = wxPyBeginAllowThreads();
24129 result = (arg1)->GetLastMonthDay(arg2,arg3);
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj = 0;
24142 wxDateTime *arg1 = (wxDateTime *) 0 ;
24143 int arg2 ;
24144 wxDateTime *result = 0 ;
24145 void *argp1 = 0 ;
24146 int res1 = 0 ;
24147 int val2 ;
24148 int ecode2 = 0 ;
24149 PyObject * obj0 = 0 ;
24150 PyObject * obj1 = 0 ;
24151 char * kwnames[] = {
24152 (char *) "self",(char *) "yday", NULL
24153 };
24154
24155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24157 if (!SWIG_IsOK(res1)) {
24158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24159 }
24160 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24161 ecode2 = SWIG_AsVal_int(obj1, &val2);
24162 if (!SWIG_IsOK(ecode2)) {
24163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24164 }
24165 arg2 = static_cast< int >(val2);
24166 {
24167 PyThreadState* __tstate = wxPyBeginAllowThreads();
24168 {
24169 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24170 result = (wxDateTime *) &_result_ref;
24171 }
24172 wxPyEndAllowThreads(__tstate);
24173 if (PyErr_Occurred()) SWIG_fail;
24174 }
24175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24176 return resultobj;
24177 fail:
24178 return NULL;
24179 }
24180
24181
24182 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24183 PyObject *resultobj = 0;
24184 wxDateTime *arg1 = (wxDateTime *) 0 ;
24185 int arg2 ;
24186 wxDateTime result;
24187 void *argp1 = 0 ;
24188 int res1 = 0 ;
24189 int val2 ;
24190 int ecode2 = 0 ;
24191 PyObject * obj0 = 0 ;
24192 PyObject * obj1 = 0 ;
24193 char * kwnames[] = {
24194 (char *) "self",(char *) "yday", NULL
24195 };
24196
24197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24199 if (!SWIG_IsOK(res1)) {
24200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24201 }
24202 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24203 ecode2 = SWIG_AsVal_int(obj1, &val2);
24204 if (!SWIG_IsOK(ecode2)) {
24205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24206 }
24207 arg2 = static_cast< int >(val2);
24208 {
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 result = (arg1)->GetYearDay(arg2);
24211 wxPyEndAllowThreads(__tstate);
24212 if (PyErr_Occurred()) SWIG_fail;
24213 }
24214 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24215 return resultobj;
24216 fail:
24217 return NULL;
24218 }
24219
24220
24221 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24222 PyObject *resultobj = 0;
24223 wxDateTime *arg1 = (wxDateTime *) 0 ;
24224 double result;
24225 void *argp1 = 0 ;
24226 int res1 = 0 ;
24227 PyObject *swig_obj[1] ;
24228
24229 if (!args) SWIG_fail;
24230 swig_obj[0] = args;
24231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24232 if (!SWIG_IsOK(res1)) {
24233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24234 }
24235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 result = (double)(arg1)->GetJulianDayNumber();
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 resultobj = SWIG_From_double(static_cast< double >(result));
24243 return resultobj;
24244 fail:
24245 return NULL;
24246 }
24247
24248
24249 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250 PyObject *resultobj = 0;
24251 wxDateTime *arg1 = (wxDateTime *) 0 ;
24252 double result;
24253 void *argp1 = 0 ;
24254 int res1 = 0 ;
24255 PyObject *swig_obj[1] ;
24256
24257 if (!args) SWIG_fail;
24258 swig_obj[0] = args;
24259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24260 if (!SWIG_IsOK(res1)) {
24261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24262 }
24263 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (double)(arg1)->GetJDN();
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 resultobj = SWIG_From_double(static_cast< double >(result));
24271 return resultobj;
24272 fail:
24273 return NULL;
24274 }
24275
24276
24277 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24278 PyObject *resultobj = 0;
24279 wxDateTime *arg1 = (wxDateTime *) 0 ;
24280 double result;
24281 void *argp1 = 0 ;
24282 int res1 = 0 ;
24283 PyObject *swig_obj[1] ;
24284
24285 if (!args) SWIG_fail;
24286 swig_obj[0] = args;
24287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24288 if (!SWIG_IsOK(res1)) {
24289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24290 }
24291 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24295 wxPyEndAllowThreads(__tstate);
24296 if (PyErr_Occurred()) SWIG_fail;
24297 }
24298 resultobj = SWIG_From_double(static_cast< double >(result));
24299 return resultobj;
24300 fail:
24301 return NULL;
24302 }
24303
24304
24305 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24306 PyObject *resultobj = 0;
24307 wxDateTime *arg1 = (wxDateTime *) 0 ;
24308 double result;
24309 void *argp1 = 0 ;
24310 int res1 = 0 ;
24311 PyObject *swig_obj[1] ;
24312
24313 if (!args) SWIG_fail;
24314 swig_obj[0] = args;
24315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24316 if (!SWIG_IsOK(res1)) {
24317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24318 }
24319 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24320 {
24321 PyThreadState* __tstate = wxPyBeginAllowThreads();
24322 result = (double)(arg1)->GetMJD();
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 resultobj = SWIG_From_double(static_cast< double >(result));
24327 return resultobj;
24328 fail:
24329 return NULL;
24330 }
24331
24332
24333 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24334 PyObject *resultobj = 0;
24335 wxDateTime *arg1 = (wxDateTime *) 0 ;
24336 double result;
24337 void *argp1 = 0 ;
24338 int res1 = 0 ;
24339 PyObject *swig_obj[1] ;
24340
24341 if (!args) SWIG_fail;
24342 swig_obj[0] = args;
24343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24344 if (!SWIG_IsOK(res1)) {
24345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24346 }
24347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24348 {
24349 PyThreadState* __tstate = wxPyBeginAllowThreads();
24350 result = (double)(arg1)->GetRataDie();
24351 wxPyEndAllowThreads(__tstate);
24352 if (PyErr_Occurred()) SWIG_fail;
24353 }
24354 resultobj = SWIG_From_double(static_cast< double >(result));
24355 return resultobj;
24356 fail:
24357 return NULL;
24358 }
24359
24360
24361 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24362 PyObject *resultobj = 0;
24363 wxDateTime *arg1 = (wxDateTime *) 0 ;
24364 wxDateTime::TimeZone *arg2 = 0 ;
24365 bool arg3 = (bool) false ;
24366 wxDateTime result;
24367 void *argp1 = 0 ;
24368 int res1 = 0 ;
24369 bool temp2 = false ;
24370 bool val3 ;
24371 int ecode3 = 0 ;
24372 PyObject * obj0 = 0 ;
24373 PyObject * obj1 = 0 ;
24374 PyObject * obj2 = 0 ;
24375 char * kwnames[] = {
24376 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24377 };
24378
24379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24381 if (!SWIG_IsOK(res1)) {
24382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24383 }
24384 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24385 {
24386 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24387 temp2 = true;
24388 }
24389 if (obj2) {
24390 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24391 if (!SWIG_IsOK(ecode3)) {
24392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24393 }
24394 arg3 = static_cast< bool >(val3);
24395 }
24396 {
24397 PyThreadState* __tstate = wxPyBeginAllowThreads();
24398 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24399 wxPyEndAllowThreads(__tstate);
24400 if (PyErr_Occurred()) SWIG_fail;
24401 }
24402 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24403 {
24404 if (temp2) delete arg2;
24405 }
24406 return resultobj;
24407 fail:
24408 {
24409 if (temp2) delete arg2;
24410 }
24411 return NULL;
24412 }
24413
24414
24415 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24416 PyObject *resultobj = 0;
24417 wxDateTime *arg1 = (wxDateTime *) 0 ;
24418 wxDateTime::TimeZone *arg2 = 0 ;
24419 bool arg3 = (bool) false ;
24420 wxDateTime *result = 0 ;
24421 void *argp1 = 0 ;
24422 int res1 = 0 ;
24423 bool temp2 = false ;
24424 bool val3 ;
24425 int ecode3 = 0 ;
24426 PyObject * obj0 = 0 ;
24427 PyObject * obj1 = 0 ;
24428 PyObject * obj2 = 0 ;
24429 char * kwnames[] = {
24430 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24431 };
24432
24433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24435 if (!SWIG_IsOK(res1)) {
24436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24437 }
24438 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24439 {
24440 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24441 temp2 = true;
24442 }
24443 if (obj2) {
24444 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24445 if (!SWIG_IsOK(ecode3)) {
24446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24447 }
24448 arg3 = static_cast< bool >(val3);
24449 }
24450 {
24451 PyThreadState* __tstate = wxPyBeginAllowThreads();
24452 {
24453 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24454 result = (wxDateTime *) &_result_ref;
24455 }
24456 wxPyEndAllowThreads(__tstate);
24457 if (PyErr_Occurred()) SWIG_fail;
24458 }
24459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24460 {
24461 if (temp2) delete arg2;
24462 }
24463 return resultobj;
24464 fail:
24465 {
24466 if (temp2) delete arg2;
24467 }
24468 return NULL;
24469 }
24470
24471
24472 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24473 PyObject *resultobj = 0;
24474 wxDateTime *arg1 = (wxDateTime *) 0 ;
24475 wxDateTime::TimeZone *arg2 = 0 ;
24476 bool arg3 = (bool) false ;
24477 wxDateTime result;
24478 void *argp1 = 0 ;
24479 int res1 = 0 ;
24480 bool temp2 = false ;
24481 bool val3 ;
24482 int ecode3 = 0 ;
24483 PyObject * obj0 = 0 ;
24484 PyObject * obj1 = 0 ;
24485 PyObject * obj2 = 0 ;
24486 char * kwnames[] = {
24487 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24488 };
24489
24490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24492 if (!SWIG_IsOK(res1)) {
24493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24494 }
24495 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24496 {
24497 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24498 temp2 = true;
24499 }
24500 if (obj2) {
24501 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24502 if (!SWIG_IsOK(ecode3)) {
24503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24504 }
24505 arg3 = static_cast< bool >(val3);
24506 }
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24510 wxPyEndAllowThreads(__tstate);
24511 if (PyErr_Occurred()) SWIG_fail;
24512 }
24513 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24514 {
24515 if (temp2) delete arg2;
24516 }
24517 return resultobj;
24518 fail:
24519 {
24520 if (temp2) delete arg2;
24521 }
24522 return NULL;
24523 }
24524
24525
24526 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24527 PyObject *resultobj = 0;
24528 wxDateTime *arg1 = (wxDateTime *) 0 ;
24529 wxDateTime::TimeZone *arg2 = 0 ;
24530 bool arg3 = (bool) false ;
24531 wxDateTime *result = 0 ;
24532 void *argp1 = 0 ;
24533 int res1 = 0 ;
24534 bool temp2 = false ;
24535 bool val3 ;
24536 int ecode3 = 0 ;
24537 PyObject * obj0 = 0 ;
24538 PyObject * obj1 = 0 ;
24539 PyObject * obj2 = 0 ;
24540 char * kwnames[] = {
24541 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24542 };
24543
24544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24546 if (!SWIG_IsOK(res1)) {
24547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24548 }
24549 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24550 {
24551 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24552 temp2 = true;
24553 }
24554 if (obj2) {
24555 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24556 if (!SWIG_IsOK(ecode3)) {
24557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24558 }
24559 arg3 = static_cast< bool >(val3);
24560 }
24561 {
24562 PyThreadState* __tstate = wxPyBeginAllowThreads();
24563 {
24564 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24565 result = (wxDateTime *) &_result_ref;
24566 }
24567 wxPyEndAllowThreads(__tstate);
24568 if (PyErr_Occurred()) SWIG_fail;
24569 }
24570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24571 {
24572 if (temp2) delete arg2;
24573 }
24574 return resultobj;
24575 fail:
24576 {
24577 if (temp2) delete arg2;
24578 }
24579 return NULL;
24580 }
24581
24582
24583 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24584 PyObject *resultobj = 0;
24585 wxDateTime *arg1 = (wxDateTime *) 0 ;
24586 bool arg2 = (bool) false ;
24587 wxDateTime result;
24588 void *argp1 = 0 ;
24589 int res1 = 0 ;
24590 bool val2 ;
24591 int ecode2 = 0 ;
24592 PyObject * obj0 = 0 ;
24593 PyObject * obj1 = 0 ;
24594 char * kwnames[] = {
24595 (char *) "self",(char *) "noDST", NULL
24596 };
24597
24598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24600 if (!SWIG_IsOK(res1)) {
24601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24602 }
24603 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24604 if (obj1) {
24605 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24606 if (!SWIG_IsOK(ecode2)) {
24607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24608 }
24609 arg2 = static_cast< bool >(val2);
24610 }
24611 {
24612 PyThreadState* __tstate = wxPyBeginAllowThreads();
24613 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24614 wxPyEndAllowThreads(__tstate);
24615 if (PyErr_Occurred()) SWIG_fail;
24616 }
24617 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24618 return resultobj;
24619 fail:
24620 return NULL;
24621 }
24622
24623
24624 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24625 PyObject *resultobj = 0;
24626 wxDateTime *arg1 = (wxDateTime *) 0 ;
24627 bool arg2 = (bool) false ;
24628 wxDateTime *result = 0 ;
24629 void *argp1 = 0 ;
24630 int res1 = 0 ;
24631 bool val2 ;
24632 int ecode2 = 0 ;
24633 PyObject * obj0 = 0 ;
24634 PyObject * obj1 = 0 ;
24635 char * kwnames[] = {
24636 (char *) "self",(char *) "noDST", NULL
24637 };
24638
24639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24641 if (!SWIG_IsOK(res1)) {
24642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24643 }
24644 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24645 if (obj1) {
24646 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24647 if (!SWIG_IsOK(ecode2)) {
24648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24649 }
24650 arg2 = static_cast< bool >(val2);
24651 }
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 {
24655 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24656 result = (wxDateTime *) &_result_ref;
24657 }
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj = 0;
24670 wxDateTime *arg1 = (wxDateTime *) 0 ;
24671 bool arg2 = (bool) false ;
24672 wxDateTime result;
24673 void *argp1 = 0 ;
24674 int res1 = 0 ;
24675 bool val2 ;
24676 int ecode2 = 0 ;
24677 PyObject * obj0 = 0 ;
24678 PyObject * obj1 = 0 ;
24679 char * kwnames[] = {
24680 (char *) "self",(char *) "noDST", NULL
24681 };
24682
24683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24685 if (!SWIG_IsOK(res1)) {
24686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24687 }
24688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24689 if (obj1) {
24690 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24691 if (!SWIG_IsOK(ecode2)) {
24692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24693 }
24694 arg2 = static_cast< bool >(val2);
24695 }
24696 {
24697 PyThreadState* __tstate = wxPyBeginAllowThreads();
24698 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24710 PyObject *resultobj = 0;
24711 wxDateTime *arg1 = (wxDateTime *) 0 ;
24712 bool arg2 = (bool) false ;
24713 wxDateTime *result = 0 ;
24714 void *argp1 = 0 ;
24715 int res1 = 0 ;
24716 bool val2 ;
24717 int ecode2 = 0 ;
24718 PyObject * obj0 = 0 ;
24719 PyObject * obj1 = 0 ;
24720 char * kwnames[] = {
24721 (char *) "self",(char *) "noDST", NULL
24722 };
24723
24724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24726 if (!SWIG_IsOK(res1)) {
24727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24728 }
24729 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24730 if (obj1) {
24731 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24732 if (!SWIG_IsOK(ecode2)) {
24733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24734 }
24735 arg2 = static_cast< bool >(val2);
24736 }
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 {
24740 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24741 result = (wxDateTime *) &_result_ref;
24742 }
24743 wxPyEndAllowThreads(__tstate);
24744 if (PyErr_Occurred()) SWIG_fail;
24745 }
24746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24747 return resultobj;
24748 fail:
24749 return NULL;
24750 }
24751
24752
24753 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24754 PyObject *resultobj = 0;
24755 wxDateTime *arg1 = (wxDateTime *) 0 ;
24756 bool arg2 = (bool) false ;
24757 wxDateTime result;
24758 void *argp1 = 0 ;
24759 int res1 = 0 ;
24760 bool val2 ;
24761 int ecode2 = 0 ;
24762 PyObject * obj0 = 0 ;
24763 PyObject * obj1 = 0 ;
24764 char * kwnames[] = {
24765 (char *) "self",(char *) "noDST", NULL
24766 };
24767
24768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24770 if (!SWIG_IsOK(res1)) {
24771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24772 }
24773 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24774 if (obj1) {
24775 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24776 if (!SWIG_IsOK(ecode2)) {
24777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24778 }
24779 arg2 = static_cast< bool >(val2);
24780 }
24781 {
24782 PyThreadState* __tstate = wxPyBeginAllowThreads();
24783 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24784 wxPyEndAllowThreads(__tstate);
24785 if (PyErr_Occurred()) SWIG_fail;
24786 }
24787 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24788 return resultobj;
24789 fail:
24790 return NULL;
24791 }
24792
24793
24794 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj = 0;
24796 wxDateTime *arg1 = (wxDateTime *) 0 ;
24797 bool arg2 = (bool) false ;
24798 wxDateTime *result = 0 ;
24799 void *argp1 = 0 ;
24800 int res1 = 0 ;
24801 bool val2 ;
24802 int ecode2 = 0 ;
24803 PyObject * obj0 = 0 ;
24804 PyObject * obj1 = 0 ;
24805 char * kwnames[] = {
24806 (char *) "self",(char *) "noDST", NULL
24807 };
24808
24809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24811 if (!SWIG_IsOK(res1)) {
24812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24813 }
24814 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24815 if (obj1) {
24816 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24817 if (!SWIG_IsOK(ecode2)) {
24818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24819 }
24820 arg2 = static_cast< bool >(val2);
24821 }
24822 {
24823 PyThreadState* __tstate = wxPyBeginAllowThreads();
24824 {
24825 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24826 result = (wxDateTime *) &_result_ref;
24827 }
24828 wxPyEndAllowThreads(__tstate);
24829 if (PyErr_Occurred()) SWIG_fail;
24830 }
24831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24839 PyObject *resultobj = 0;
24840 wxDateTime *arg1 = (wxDateTime *) 0 ;
24841 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24842 int result;
24843 void *argp1 = 0 ;
24844 int res1 = 0 ;
24845 int val2 ;
24846 int ecode2 = 0 ;
24847 PyObject * obj0 = 0 ;
24848 PyObject * obj1 = 0 ;
24849 char * kwnames[] = {
24850 (char *) "self",(char *) "country", NULL
24851 };
24852
24853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24855 if (!SWIG_IsOK(res1)) {
24856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24857 }
24858 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24859 if (obj1) {
24860 ecode2 = SWIG_AsVal_int(obj1, &val2);
24861 if (!SWIG_IsOK(ecode2)) {
24862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24863 }
24864 arg2 = static_cast< wxDateTime::Country >(val2);
24865 }
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 result = (int)(arg1)->IsDST(arg2);
24869 wxPyEndAllowThreads(__tstate);
24870 if (PyErr_Occurred()) SWIG_fail;
24871 }
24872 resultobj = SWIG_From_int(static_cast< int >(result));
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24880 PyObject *resultobj = 0;
24881 wxDateTime *arg1 = (wxDateTime *) 0 ;
24882 bool result;
24883 void *argp1 = 0 ;
24884 int res1 = 0 ;
24885 PyObject *swig_obj[1] ;
24886
24887 if (!args) SWIG_fail;
24888 swig_obj[0] = args;
24889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24890 if (!SWIG_IsOK(res1)) {
24891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24892 }
24893 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24894 {
24895 PyThreadState* __tstate = wxPyBeginAllowThreads();
24896 result = (bool)((wxDateTime const *)arg1)->IsValid();
24897 wxPyEndAllowThreads(__tstate);
24898 if (PyErr_Occurred()) SWIG_fail;
24899 }
24900 {
24901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24902 }
24903 return resultobj;
24904 fail:
24905 return NULL;
24906 }
24907
24908
24909 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24910 PyObject *resultobj = 0;
24911 wxDateTime *arg1 = (wxDateTime *) 0 ;
24912 time_t result;
24913 void *argp1 = 0 ;
24914 int res1 = 0 ;
24915 PyObject *swig_obj[1] ;
24916
24917 if (!args) SWIG_fail;
24918 swig_obj[0] = args;
24919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24920 if (!SWIG_IsOK(res1)) {
24921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24922 }
24923 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24924 {
24925 PyThreadState* __tstate = wxPyBeginAllowThreads();
24926 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24927 wxPyEndAllowThreads(__tstate);
24928 if (PyErr_Occurred()) SWIG_fail;
24929 }
24930 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24931 return resultobj;
24932 fail:
24933 return NULL;
24934 }
24935
24936
24937 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24938 PyObject *resultobj = 0;
24939 wxDateTime *arg1 = (wxDateTime *) 0 ;
24940 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24941 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24942 int result;
24943 void *argp1 = 0 ;
24944 int res1 = 0 ;
24945 bool temp2 = false ;
24946 PyObject * obj0 = 0 ;
24947 PyObject * obj1 = 0 ;
24948 char * kwnames[] = {
24949 (char *) "self",(char *) "tz", NULL
24950 };
24951
24952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24954 if (!SWIG_IsOK(res1)) {
24955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24956 }
24957 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24958 if (obj1) {
24959 {
24960 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24961 temp2 = true;
24962 }
24963 }
24964 {
24965 PyThreadState* __tstate = wxPyBeginAllowThreads();
24966 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 resultobj = SWIG_From_int(static_cast< int >(result));
24971 {
24972 if (temp2) delete arg2;
24973 }
24974 return resultobj;
24975 fail:
24976 {
24977 if (temp2) delete arg2;
24978 }
24979 return NULL;
24980 }
24981
24982
24983 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24984 PyObject *resultobj = 0;
24985 wxDateTime *arg1 = (wxDateTime *) 0 ;
24986 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24987 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24988 wxDateTime::Month result;
24989 void *argp1 = 0 ;
24990 int res1 = 0 ;
24991 bool temp2 = false ;
24992 PyObject * obj0 = 0 ;
24993 PyObject * obj1 = 0 ;
24994 char * kwnames[] = {
24995 (char *) "self",(char *) "tz", NULL
24996 };
24997
24998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25000 if (!SWIG_IsOK(res1)) {
25001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25002 }
25003 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25004 if (obj1) {
25005 {
25006 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25007 temp2 = true;
25008 }
25009 }
25010 {
25011 PyThreadState* __tstate = wxPyBeginAllowThreads();
25012 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 resultobj = SWIG_From_int(static_cast< int >(result));
25017 {
25018 if (temp2) delete arg2;
25019 }
25020 return resultobj;
25021 fail:
25022 {
25023 if (temp2) delete arg2;
25024 }
25025 return NULL;
25026 }
25027
25028
25029 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25030 PyObject *resultobj = 0;
25031 wxDateTime *arg1 = (wxDateTime *) 0 ;
25032 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25033 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25034 int result;
25035 void *argp1 = 0 ;
25036 int res1 = 0 ;
25037 bool temp2 = false ;
25038 PyObject * obj0 = 0 ;
25039 PyObject * obj1 = 0 ;
25040 char * kwnames[] = {
25041 (char *) "self",(char *) "tz", NULL
25042 };
25043
25044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25046 if (!SWIG_IsOK(res1)) {
25047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25048 }
25049 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25050 if (obj1) {
25051 {
25052 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25053 temp2 = true;
25054 }
25055 }
25056 {
25057 PyThreadState* __tstate = wxPyBeginAllowThreads();
25058 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 resultobj = SWIG_From_int(static_cast< int >(result));
25063 {
25064 if (temp2) delete arg2;
25065 }
25066 return resultobj;
25067 fail:
25068 {
25069 if (temp2) delete arg2;
25070 }
25071 return NULL;
25072 }
25073
25074
25075 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25076 PyObject *resultobj = 0;
25077 wxDateTime *arg1 = (wxDateTime *) 0 ;
25078 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25079 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25080 wxDateTime::WeekDay result;
25081 void *argp1 = 0 ;
25082 int res1 = 0 ;
25083 bool temp2 = false ;
25084 PyObject * obj0 = 0 ;
25085 PyObject * obj1 = 0 ;
25086 char * kwnames[] = {
25087 (char *) "self",(char *) "tz", NULL
25088 };
25089
25090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25092 if (!SWIG_IsOK(res1)) {
25093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25094 }
25095 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25096 if (obj1) {
25097 {
25098 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25099 temp2 = true;
25100 }
25101 }
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 resultobj = SWIG_From_int(static_cast< int >(result));
25109 {
25110 if (temp2) delete arg2;
25111 }
25112 return resultobj;
25113 fail:
25114 {
25115 if (temp2) delete arg2;
25116 }
25117 return NULL;
25118 }
25119
25120
25121 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25122 PyObject *resultobj = 0;
25123 wxDateTime *arg1 = (wxDateTime *) 0 ;
25124 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25125 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25126 int result;
25127 void *argp1 = 0 ;
25128 int res1 = 0 ;
25129 bool temp2 = false ;
25130 PyObject * obj0 = 0 ;
25131 PyObject * obj1 = 0 ;
25132 char * kwnames[] = {
25133 (char *) "self",(char *) "tz", NULL
25134 };
25135
25136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25138 if (!SWIG_IsOK(res1)) {
25139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25140 }
25141 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25142 if (obj1) {
25143 {
25144 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25145 temp2 = true;
25146 }
25147 }
25148 {
25149 PyThreadState* __tstate = wxPyBeginAllowThreads();
25150 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25151 wxPyEndAllowThreads(__tstate);
25152 if (PyErr_Occurred()) SWIG_fail;
25153 }
25154 resultobj = SWIG_From_int(static_cast< int >(result));
25155 {
25156 if (temp2) delete arg2;
25157 }
25158 return resultobj;
25159 fail:
25160 {
25161 if (temp2) delete arg2;
25162 }
25163 return NULL;
25164 }
25165
25166
25167 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25168 PyObject *resultobj = 0;
25169 wxDateTime *arg1 = (wxDateTime *) 0 ;
25170 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25171 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25172 int result;
25173 void *argp1 = 0 ;
25174 int res1 = 0 ;
25175 bool temp2 = false ;
25176 PyObject * obj0 = 0 ;
25177 PyObject * obj1 = 0 ;
25178 char * kwnames[] = {
25179 (char *) "self",(char *) "tz", NULL
25180 };
25181
25182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25184 if (!SWIG_IsOK(res1)) {
25185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25186 }
25187 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25188 if (obj1) {
25189 {
25190 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25191 temp2 = true;
25192 }
25193 }
25194 {
25195 PyThreadState* __tstate = wxPyBeginAllowThreads();
25196 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25197 wxPyEndAllowThreads(__tstate);
25198 if (PyErr_Occurred()) SWIG_fail;
25199 }
25200 resultobj = SWIG_From_int(static_cast< int >(result));
25201 {
25202 if (temp2) delete arg2;
25203 }
25204 return resultobj;
25205 fail:
25206 {
25207 if (temp2) delete arg2;
25208 }
25209 return NULL;
25210 }
25211
25212
25213 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25214 PyObject *resultobj = 0;
25215 wxDateTime *arg1 = (wxDateTime *) 0 ;
25216 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25217 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25218 int result;
25219 void *argp1 = 0 ;
25220 int res1 = 0 ;
25221 bool temp2 = false ;
25222 PyObject * obj0 = 0 ;
25223 PyObject * obj1 = 0 ;
25224 char * kwnames[] = {
25225 (char *) "self",(char *) "tz", NULL
25226 };
25227
25228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25230 if (!SWIG_IsOK(res1)) {
25231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25232 }
25233 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25234 if (obj1) {
25235 {
25236 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25237 temp2 = true;
25238 }
25239 }
25240 {
25241 PyThreadState* __tstate = wxPyBeginAllowThreads();
25242 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 resultobj = SWIG_From_int(static_cast< int >(result));
25247 {
25248 if (temp2) delete arg2;
25249 }
25250 return resultobj;
25251 fail:
25252 {
25253 if (temp2) delete arg2;
25254 }
25255 return NULL;
25256 }
25257
25258
25259 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25260 PyObject *resultobj = 0;
25261 wxDateTime *arg1 = (wxDateTime *) 0 ;
25262 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25263 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25264 int result;
25265 void *argp1 = 0 ;
25266 int res1 = 0 ;
25267 bool temp2 = false ;
25268 PyObject * obj0 = 0 ;
25269 PyObject * obj1 = 0 ;
25270 char * kwnames[] = {
25271 (char *) "self",(char *) "tz", NULL
25272 };
25273
25274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25276 if (!SWIG_IsOK(res1)) {
25277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25278 }
25279 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25280 if (obj1) {
25281 {
25282 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25283 temp2 = true;
25284 }
25285 }
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25289 wxPyEndAllowThreads(__tstate);
25290 if (PyErr_Occurred()) SWIG_fail;
25291 }
25292 resultobj = SWIG_From_int(static_cast< int >(result));
25293 {
25294 if (temp2) delete arg2;
25295 }
25296 return resultobj;
25297 fail:
25298 {
25299 if (temp2) delete arg2;
25300 }
25301 return NULL;
25302 }
25303
25304
25305 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25306 PyObject *resultobj = 0;
25307 wxDateTime *arg1 = (wxDateTime *) 0 ;
25308 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25309 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25310 int result;
25311 void *argp1 = 0 ;
25312 int res1 = 0 ;
25313 bool temp2 = false ;
25314 PyObject * obj0 = 0 ;
25315 PyObject * obj1 = 0 ;
25316 char * kwnames[] = {
25317 (char *) "self",(char *) "tz", NULL
25318 };
25319
25320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25322 if (!SWIG_IsOK(res1)) {
25323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25324 }
25325 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25326 if (obj1) {
25327 {
25328 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25329 temp2 = true;
25330 }
25331 }
25332 {
25333 PyThreadState* __tstate = wxPyBeginAllowThreads();
25334 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25335 wxPyEndAllowThreads(__tstate);
25336 if (PyErr_Occurred()) SWIG_fail;
25337 }
25338 resultobj = SWIG_From_int(static_cast< int >(result));
25339 {
25340 if (temp2) delete arg2;
25341 }
25342 return resultobj;
25343 fail:
25344 {
25345 if (temp2) delete arg2;
25346 }
25347 return NULL;
25348 }
25349
25350
25351 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25352 PyObject *resultobj = 0;
25353 wxDateTime *arg1 = (wxDateTime *) 0 ;
25354 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25355 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25356 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25357 int result;
25358 void *argp1 = 0 ;
25359 int res1 = 0 ;
25360 int val2 ;
25361 int ecode2 = 0 ;
25362 bool temp3 = false ;
25363 PyObject * obj0 = 0 ;
25364 PyObject * obj1 = 0 ;
25365 PyObject * obj2 = 0 ;
25366 char * kwnames[] = {
25367 (char *) "self",(char *) "flags",(char *) "tz", NULL
25368 };
25369
25370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25372 if (!SWIG_IsOK(res1)) {
25373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25374 }
25375 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25376 if (obj1) {
25377 ecode2 = SWIG_AsVal_int(obj1, &val2);
25378 if (!SWIG_IsOK(ecode2)) {
25379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25380 }
25381 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25382 }
25383 if (obj2) {
25384 {
25385 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25386 temp3 = true;
25387 }
25388 }
25389 {
25390 PyThreadState* __tstate = wxPyBeginAllowThreads();
25391 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25392 wxPyEndAllowThreads(__tstate);
25393 if (PyErr_Occurred()) SWIG_fail;
25394 }
25395 resultobj = SWIG_From_int(static_cast< int >(result));
25396 {
25397 if (temp3) delete arg3;
25398 }
25399 return resultobj;
25400 fail:
25401 {
25402 if (temp3) delete arg3;
25403 }
25404 return NULL;
25405 }
25406
25407
25408 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25409 PyObject *resultobj = 0;
25410 wxDateTime *arg1 = (wxDateTime *) 0 ;
25411 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25412 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25413 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25414 int result;
25415 void *argp1 = 0 ;
25416 int res1 = 0 ;
25417 int val2 ;
25418 int ecode2 = 0 ;
25419 bool temp3 = false ;
25420 PyObject * obj0 = 0 ;
25421 PyObject * obj1 = 0 ;
25422 PyObject * obj2 = 0 ;
25423 char * kwnames[] = {
25424 (char *) "self",(char *) "flags",(char *) "tz", NULL
25425 };
25426
25427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25429 if (!SWIG_IsOK(res1)) {
25430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25431 }
25432 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25433 if (obj1) {
25434 ecode2 = SWIG_AsVal_int(obj1, &val2);
25435 if (!SWIG_IsOK(ecode2)) {
25436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25437 }
25438 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25439 }
25440 if (obj2) {
25441 {
25442 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25443 temp3 = true;
25444 }
25445 }
25446 {
25447 PyThreadState* __tstate = wxPyBeginAllowThreads();
25448 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 resultobj = SWIG_From_int(static_cast< int >(result));
25453 {
25454 if (temp3) delete arg3;
25455 }
25456 return resultobj;
25457 fail:
25458 {
25459 if (temp3) delete arg3;
25460 }
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25466 PyObject *resultobj = 0;
25467 wxDateTime *arg1 = (wxDateTime *) 0 ;
25468 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25469 bool result;
25470 void *argp1 = 0 ;
25471 int res1 = 0 ;
25472 int val2 ;
25473 int ecode2 = 0 ;
25474 PyObject * obj0 = 0 ;
25475 PyObject * obj1 = 0 ;
25476 char * kwnames[] = {
25477 (char *) "self",(char *) "country", NULL
25478 };
25479
25480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25482 if (!SWIG_IsOK(res1)) {
25483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25484 }
25485 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25486 if (obj1) {
25487 ecode2 = SWIG_AsVal_int(obj1, &val2);
25488 if (!SWIG_IsOK(ecode2)) {
25489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25490 }
25491 arg2 = static_cast< wxDateTime::Country >(val2);
25492 }
25493 {
25494 PyThreadState* __tstate = wxPyBeginAllowThreads();
25495 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25496 wxPyEndAllowThreads(__tstate);
25497 if (PyErr_Occurred()) SWIG_fail;
25498 }
25499 {
25500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25501 }
25502 return resultobj;
25503 fail:
25504 return NULL;
25505 }
25506
25507
25508 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25509 PyObject *resultobj = 0;
25510 wxDateTime *arg1 = (wxDateTime *) 0 ;
25511 wxDateTime *arg2 = 0 ;
25512 bool result;
25513 void *argp1 = 0 ;
25514 int res1 = 0 ;
25515 void *argp2 = 0 ;
25516 int res2 = 0 ;
25517 PyObject * obj0 = 0 ;
25518 PyObject * obj1 = 0 ;
25519 char * kwnames[] = {
25520 (char *) "self",(char *) "datetime", NULL
25521 };
25522
25523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25525 if (!SWIG_IsOK(res1)) {
25526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25527 }
25528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25529 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25530 if (!SWIG_IsOK(res2)) {
25531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25532 }
25533 if (!argp2) {
25534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25535 }
25536 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25537 {
25538 PyThreadState* __tstate = wxPyBeginAllowThreads();
25539 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25540 wxPyEndAllowThreads(__tstate);
25541 if (PyErr_Occurred()) SWIG_fail;
25542 }
25543 {
25544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25545 }
25546 return resultobj;
25547 fail:
25548 return NULL;
25549 }
25550
25551
25552 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25553 PyObject *resultobj = 0;
25554 wxDateTime *arg1 = (wxDateTime *) 0 ;
25555 wxDateTime *arg2 = 0 ;
25556 bool result;
25557 void *argp1 = 0 ;
25558 int res1 = 0 ;
25559 void *argp2 = 0 ;
25560 int res2 = 0 ;
25561 PyObject * obj0 = 0 ;
25562 PyObject * obj1 = 0 ;
25563 char * kwnames[] = {
25564 (char *) "self",(char *) "datetime", NULL
25565 };
25566
25567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25569 if (!SWIG_IsOK(res1)) {
25570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25571 }
25572 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25573 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25574 if (!SWIG_IsOK(res2)) {
25575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25576 }
25577 if (!argp2) {
25578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25579 }
25580 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25581 {
25582 PyThreadState* __tstate = wxPyBeginAllowThreads();
25583 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25584 wxPyEndAllowThreads(__tstate);
25585 if (PyErr_Occurred()) SWIG_fail;
25586 }
25587 {
25588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25589 }
25590 return resultobj;
25591 fail:
25592 return NULL;
25593 }
25594
25595
25596 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25597 PyObject *resultobj = 0;
25598 wxDateTime *arg1 = (wxDateTime *) 0 ;
25599 wxDateTime *arg2 = 0 ;
25600 bool result;
25601 void *argp1 = 0 ;
25602 int res1 = 0 ;
25603 void *argp2 = 0 ;
25604 int res2 = 0 ;
25605 PyObject * obj0 = 0 ;
25606 PyObject * obj1 = 0 ;
25607 char * kwnames[] = {
25608 (char *) "self",(char *) "datetime", NULL
25609 };
25610
25611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25613 if (!SWIG_IsOK(res1)) {
25614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25615 }
25616 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25617 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25618 if (!SWIG_IsOK(res2)) {
25619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25620 }
25621 if (!argp2) {
25622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25623 }
25624 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 {
25632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25633 }
25634 return resultobj;
25635 fail:
25636 return NULL;
25637 }
25638
25639
25640 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25641 PyObject *resultobj = 0;
25642 wxDateTime *arg1 = (wxDateTime *) 0 ;
25643 wxDateTime *arg2 = 0 ;
25644 wxDateTime *arg3 = 0 ;
25645 bool result;
25646 void *argp1 = 0 ;
25647 int res1 = 0 ;
25648 void *argp2 = 0 ;
25649 int res2 = 0 ;
25650 void *argp3 = 0 ;
25651 int res3 = 0 ;
25652 PyObject * obj0 = 0 ;
25653 PyObject * obj1 = 0 ;
25654 PyObject * obj2 = 0 ;
25655 char * kwnames[] = {
25656 (char *) "self",(char *) "t1",(char *) "t2", NULL
25657 };
25658
25659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25661 if (!SWIG_IsOK(res1)) {
25662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25663 }
25664 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25665 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25666 if (!SWIG_IsOK(res2)) {
25667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25668 }
25669 if (!argp2) {
25670 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25671 }
25672 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25673 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25674 if (!SWIG_IsOK(res3)) {
25675 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25676 }
25677 if (!argp3) {
25678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25679 }
25680 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25684 wxPyEndAllowThreads(__tstate);
25685 if (PyErr_Occurred()) SWIG_fail;
25686 }
25687 {
25688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25689 }
25690 return resultobj;
25691 fail:
25692 return NULL;
25693 }
25694
25695
25696 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj = 0;
25698 wxDateTime *arg1 = (wxDateTime *) 0 ;
25699 wxDateTime *arg2 = 0 ;
25700 wxDateTime *arg3 = 0 ;
25701 bool result;
25702 void *argp1 = 0 ;
25703 int res1 = 0 ;
25704 void *argp2 = 0 ;
25705 int res2 = 0 ;
25706 void *argp3 = 0 ;
25707 int res3 = 0 ;
25708 PyObject * obj0 = 0 ;
25709 PyObject * obj1 = 0 ;
25710 PyObject * obj2 = 0 ;
25711 char * kwnames[] = {
25712 (char *) "self",(char *) "t1",(char *) "t2", NULL
25713 };
25714
25715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25719 }
25720 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25722 if (!SWIG_IsOK(res2)) {
25723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25724 }
25725 if (!argp2) {
25726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25727 }
25728 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25729 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25730 if (!SWIG_IsOK(res3)) {
25731 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25732 }
25733 if (!argp3) {
25734 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25735 }
25736 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25737 {
25738 PyThreadState* __tstate = wxPyBeginAllowThreads();
25739 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 {
25744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25745 }
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj = 0;
25754 wxDateTime *arg1 = (wxDateTime *) 0 ;
25755 wxDateTime *arg2 = 0 ;
25756 bool result;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 void *argp2 = 0 ;
25760 int res2 = 0 ;
25761 PyObject * obj0 = 0 ;
25762 PyObject * obj1 = 0 ;
25763 char * kwnames[] = {
25764 (char *) "self",(char *) "dt", NULL
25765 };
25766
25767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25769 if (!SWIG_IsOK(res1)) {
25770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25771 }
25772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25773 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25774 if (!SWIG_IsOK(res2)) {
25775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25776 }
25777 if (!argp2) {
25778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25779 }
25780 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25781 {
25782 PyThreadState* __tstate = wxPyBeginAllowThreads();
25783 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25784 wxPyEndAllowThreads(__tstate);
25785 if (PyErr_Occurred()) SWIG_fail;
25786 }
25787 {
25788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25789 }
25790 return resultobj;
25791 fail:
25792 return NULL;
25793 }
25794
25795
25796 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25797 PyObject *resultobj = 0;
25798 wxDateTime *arg1 = (wxDateTime *) 0 ;
25799 wxDateTime *arg2 = 0 ;
25800 bool result;
25801 void *argp1 = 0 ;
25802 int res1 = 0 ;
25803 void *argp2 = 0 ;
25804 int res2 = 0 ;
25805 PyObject * obj0 = 0 ;
25806 PyObject * obj1 = 0 ;
25807 char * kwnames[] = {
25808 (char *) "self",(char *) "dt", NULL
25809 };
25810
25811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25813 if (!SWIG_IsOK(res1)) {
25814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25815 }
25816 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25817 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25818 if (!SWIG_IsOK(res2)) {
25819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25820 }
25821 if (!argp2) {
25822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25823 }
25824 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25825 {
25826 PyThreadState* __tstate = wxPyBeginAllowThreads();
25827 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25828 wxPyEndAllowThreads(__tstate);
25829 if (PyErr_Occurred()) SWIG_fail;
25830 }
25831 {
25832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25833 }
25834 return resultobj;
25835 fail:
25836 return NULL;
25837 }
25838
25839
25840 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25841 PyObject *resultobj = 0;
25842 wxDateTime *arg1 = (wxDateTime *) 0 ;
25843 wxDateTime *arg2 = 0 ;
25844 wxTimeSpan *arg3 = 0 ;
25845 bool result;
25846 void *argp1 = 0 ;
25847 int res1 = 0 ;
25848 void *argp2 = 0 ;
25849 int res2 = 0 ;
25850 void *argp3 = 0 ;
25851 int res3 = 0 ;
25852 PyObject * obj0 = 0 ;
25853 PyObject * obj1 = 0 ;
25854 PyObject * obj2 = 0 ;
25855 char * kwnames[] = {
25856 (char *) "self",(char *) "dt",(char *) "ts", NULL
25857 };
25858
25859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25861 if (!SWIG_IsOK(res1)) {
25862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25863 }
25864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25865 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25866 if (!SWIG_IsOK(res2)) {
25867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25868 }
25869 if (!argp2) {
25870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25871 }
25872 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25873 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25874 if (!SWIG_IsOK(res3)) {
25875 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25876 }
25877 if (!argp3) {
25878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25879 }
25880 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25881 {
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25884 wxPyEndAllowThreads(__tstate);
25885 if (PyErr_Occurred()) SWIG_fail;
25886 }
25887 {
25888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25889 }
25890 return resultobj;
25891 fail:
25892 return NULL;
25893 }
25894
25895
25896 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25897 PyObject *resultobj = 0;
25898 wxDateTime *arg1 = (wxDateTime *) 0 ;
25899 wxTimeSpan *arg2 = 0 ;
25900 wxDateTime *result = 0 ;
25901 void *argp1 = 0 ;
25902 int res1 = 0 ;
25903 void *argp2 = 0 ;
25904 int res2 = 0 ;
25905 PyObject * obj0 = 0 ;
25906 PyObject * obj1 = 0 ;
25907 char * kwnames[] = {
25908 (char *) "self",(char *) "diff", NULL
25909 };
25910
25911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25913 if (!SWIG_IsOK(res1)) {
25914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25915 }
25916 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25917 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25918 if (!SWIG_IsOK(res2)) {
25919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25920 }
25921 if (!argp2) {
25922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25923 }
25924 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25925 {
25926 PyThreadState* __tstate = wxPyBeginAllowThreads();
25927 {
25928 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25929 result = (wxDateTime *) &_result_ref;
25930 }
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25935 return resultobj;
25936 fail:
25937 return NULL;
25938 }
25939
25940
25941 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25942 PyObject *resultobj = 0;
25943 wxDateTime *arg1 = (wxDateTime *) 0 ;
25944 wxDateSpan *arg2 = 0 ;
25945 wxDateTime *result = 0 ;
25946 void *argp1 = 0 ;
25947 int res1 = 0 ;
25948 void *argp2 = 0 ;
25949 int res2 = 0 ;
25950 PyObject * obj0 = 0 ;
25951 PyObject * obj1 = 0 ;
25952 char * kwnames[] = {
25953 (char *) "self",(char *) "diff", NULL
25954 };
25955
25956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25958 if (!SWIG_IsOK(res1)) {
25959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25960 }
25961 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25962 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25963 if (!SWIG_IsOK(res2)) {
25964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25965 }
25966 if (!argp2) {
25967 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25968 }
25969 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25970 {
25971 PyThreadState* __tstate = wxPyBeginAllowThreads();
25972 {
25973 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25974 result = (wxDateTime *) &_result_ref;
25975 }
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj = 0;
25988 wxDateTime *arg1 = (wxDateTime *) 0 ;
25989 wxTimeSpan *arg2 = 0 ;
25990 wxDateTime *result = 0 ;
25991 void *argp1 = 0 ;
25992 int res1 = 0 ;
25993 void *argp2 = 0 ;
25994 int res2 = 0 ;
25995 PyObject * obj0 = 0 ;
25996 PyObject * obj1 = 0 ;
25997 char * kwnames[] = {
25998 (char *) "self",(char *) "diff", NULL
25999 };
26000
26001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26003 if (!SWIG_IsOK(res1)) {
26004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26005 }
26006 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26008 if (!SWIG_IsOK(res2)) {
26009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26010 }
26011 if (!argp2) {
26012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26013 }
26014 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26015 {
26016 PyThreadState* __tstate = wxPyBeginAllowThreads();
26017 {
26018 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26019 result = (wxDateTime *) &_result_ref;
26020 }
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26032 PyObject *resultobj = 0;
26033 wxDateTime *arg1 = (wxDateTime *) 0 ;
26034 wxDateSpan *arg2 = 0 ;
26035 wxDateTime *result = 0 ;
26036 void *argp1 = 0 ;
26037 int res1 = 0 ;
26038 void *argp2 = 0 ;
26039 int res2 = 0 ;
26040 PyObject * obj0 = 0 ;
26041 PyObject * obj1 = 0 ;
26042 char * kwnames[] = {
26043 (char *) "self",(char *) "diff", NULL
26044 };
26045
26046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26048 if (!SWIG_IsOK(res1)) {
26049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26050 }
26051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26053 if (!SWIG_IsOK(res2)) {
26054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26055 }
26056 if (!argp2) {
26057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26058 }
26059 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26060 {
26061 PyThreadState* __tstate = wxPyBeginAllowThreads();
26062 {
26063 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26064 result = (wxDateTime *) &_result_ref;
26065 }
26066 wxPyEndAllowThreads(__tstate);
26067 if (PyErr_Occurred()) SWIG_fail;
26068 }
26069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26070 return resultobj;
26071 fail:
26072 return NULL;
26073 }
26074
26075
26076 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26077 PyObject *resultobj = 0;
26078 wxDateTime *arg1 = (wxDateTime *) 0 ;
26079 wxDateTime *arg2 = 0 ;
26080 wxTimeSpan result;
26081 void *argp1 = 0 ;
26082 int res1 = 0 ;
26083 void *argp2 = 0 ;
26084 int res2 = 0 ;
26085 PyObject * obj0 = 0 ;
26086 PyObject * obj1 = 0 ;
26087 char * kwnames[] = {
26088 (char *) "self",(char *) "dt", NULL
26089 };
26090
26091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26093 if (!SWIG_IsOK(res1)) {
26094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26095 }
26096 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26098 if (!SWIG_IsOK(res2)) {
26099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26100 }
26101 if (!argp2) {
26102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26103 }
26104 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26108 wxPyEndAllowThreads(__tstate);
26109 if (PyErr_Occurred()) SWIG_fail;
26110 }
26111 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26112 return resultobj;
26113 fail:
26114 return NULL;
26115 }
26116
26117
26118 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26119 PyObject *resultobj = 0;
26120 wxDateTime *arg1 = (wxDateTime *) 0 ;
26121 wxTimeSpan *arg2 = 0 ;
26122 wxDateTime *result = 0 ;
26123 void *argp1 = 0 ;
26124 int res1 = 0 ;
26125 void *argp2 = 0 ;
26126 int res2 = 0 ;
26127
26128 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26130 if (!SWIG_IsOK(res1)) {
26131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26132 }
26133 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26134 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26135 if (!SWIG_IsOK(res2)) {
26136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26137 }
26138 if (!argp2) {
26139 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26140 }
26141 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26142 {
26143 PyThreadState* __tstate = wxPyBeginAllowThreads();
26144 {
26145 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26146 result = (wxDateTime *) &_result_ref;
26147 }
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26159 PyObject *resultobj = 0;
26160 wxDateTime *arg1 = (wxDateTime *) 0 ;
26161 wxDateSpan *arg2 = 0 ;
26162 wxDateTime *result = 0 ;
26163 void *argp1 = 0 ;
26164 int res1 = 0 ;
26165 void *argp2 = 0 ;
26166 int res2 = 0 ;
26167
26168 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26172 }
26173 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26174 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26175 if (!SWIG_IsOK(res2)) {
26176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26177 }
26178 if (!argp2) {
26179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26180 }
26181 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 {
26185 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26186 result = (wxDateTime *) &_result_ref;
26187 }
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26199 int argc;
26200 PyObject *argv[3];
26201
26202 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26203 --argc;
26204 if (argc == 2) {
26205 int _v = 0;
26206 {
26207 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26208 _v = SWIG_CheckState(res);
26209 }
26210 if (!_v) goto check_1;
26211 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26212 }
26213 check_1:
26214
26215 if (argc == 2) {
26216 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26217 }
26218
26219 fail:
26220 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26221 return NULL;
26222 }
26223
26224
26225 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26226 PyObject *resultobj = 0;
26227 wxDateTime *arg1 = (wxDateTime *) 0 ;
26228 wxTimeSpan *arg2 = 0 ;
26229 wxDateTime *result = 0 ;
26230 void *argp1 = 0 ;
26231 int res1 = 0 ;
26232 void *argp2 = 0 ;
26233 int res2 = 0 ;
26234
26235 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26237 if (!SWIG_IsOK(res1)) {
26238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26239 }
26240 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26241 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26242 if (!SWIG_IsOK(res2)) {
26243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26244 }
26245 if (!argp2) {
26246 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26247 }
26248 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26249 {
26250 PyThreadState* __tstate = wxPyBeginAllowThreads();
26251 {
26252 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26253 result = (wxDateTime *) &_result_ref;
26254 }
26255 wxPyEndAllowThreads(__tstate);
26256 if (PyErr_Occurred()) SWIG_fail;
26257 }
26258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26259 return resultobj;
26260 fail:
26261 return NULL;
26262 }
26263
26264
26265 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26266 PyObject *resultobj = 0;
26267 wxDateTime *arg1 = (wxDateTime *) 0 ;
26268 wxDateSpan *arg2 = 0 ;
26269 wxDateTime *result = 0 ;
26270 void *argp1 = 0 ;
26271 int res1 = 0 ;
26272 void *argp2 = 0 ;
26273 int res2 = 0 ;
26274
26275 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26277 if (!SWIG_IsOK(res1)) {
26278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26279 }
26280 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26281 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26282 if (!SWIG_IsOK(res2)) {
26283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26284 }
26285 if (!argp2) {
26286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26287 }
26288 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 {
26292 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26293 result = (wxDateTime *) &_result_ref;
26294 }
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26306 int argc;
26307 PyObject *argv[3];
26308
26309 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26310 --argc;
26311 if (argc == 2) {
26312 int _v = 0;
26313 {
26314 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26315 _v = SWIG_CheckState(res);
26316 }
26317 if (!_v) goto check_1;
26318 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26319 }
26320 check_1:
26321
26322 if (argc == 2) {
26323 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26324 }
26325
26326 fail:
26327 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26328 return NULL;
26329 }
26330
26331
26332 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26333 PyObject *resultobj = 0;
26334 wxDateTime *arg1 = (wxDateTime *) 0 ;
26335 wxTimeSpan *arg2 = 0 ;
26336 wxDateTime result;
26337 void *argp1 = 0 ;
26338 int res1 = 0 ;
26339 void *argp2 = 0 ;
26340 int res2 = 0 ;
26341
26342 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26344 if (!SWIG_IsOK(res1)) {
26345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26346 }
26347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26348 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26349 if (!SWIG_IsOK(res2)) {
26350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26351 }
26352 if (!argp2) {
26353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26354 }
26355 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26356 {
26357 PyThreadState* __tstate = wxPyBeginAllowThreads();
26358 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26370 PyObject *resultobj = 0;
26371 wxDateTime *arg1 = (wxDateTime *) 0 ;
26372 wxDateSpan *arg2 = 0 ;
26373 wxDateTime result;
26374 void *argp1 = 0 ;
26375 int res1 = 0 ;
26376 void *argp2 = 0 ;
26377 int res2 = 0 ;
26378
26379 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26381 if (!SWIG_IsOK(res1)) {
26382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26383 }
26384 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26385 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26386 if (!SWIG_IsOK(res2)) {
26387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26388 }
26389 if (!argp2) {
26390 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26391 }
26392 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26407 int argc;
26408 PyObject *argv[3];
26409
26410 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26411 --argc;
26412 if (argc == 2) {
26413 int _v = 0;
26414 {
26415 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26416 _v = SWIG_CheckState(res);
26417 }
26418 if (!_v) goto check_1;
26419 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26420 }
26421 check_1:
26422
26423 if (argc == 2) {
26424 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26425 }
26426
26427 fail:
26428 Py_INCREF(Py_NotImplemented);
26429 return Py_NotImplemented;
26430 }
26431
26432
26433 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26434 PyObject *resultobj = 0;
26435 wxDateTime *arg1 = (wxDateTime *) 0 ;
26436 wxDateTime *arg2 = 0 ;
26437 wxTimeSpan result;
26438 void *argp1 = 0 ;
26439 int res1 = 0 ;
26440 void *argp2 = 0 ;
26441 int res2 = 0 ;
26442
26443 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26445 if (!SWIG_IsOK(res1)) {
26446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26447 }
26448 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26449 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26450 if (!SWIG_IsOK(res2)) {
26451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26452 }
26453 if (!argp2) {
26454 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26455 }
26456 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26457 {
26458 PyThreadState* __tstate = wxPyBeginAllowThreads();
26459 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26460 wxPyEndAllowThreads(__tstate);
26461 if (PyErr_Occurred()) SWIG_fail;
26462 }
26463 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26464 return resultobj;
26465 fail:
26466 return NULL;
26467 }
26468
26469
26470 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26471 PyObject *resultobj = 0;
26472 wxDateTime *arg1 = (wxDateTime *) 0 ;
26473 wxTimeSpan *arg2 = 0 ;
26474 wxDateTime result;
26475 void *argp1 = 0 ;
26476 int res1 = 0 ;
26477 void *argp2 = 0 ;
26478 int res2 = 0 ;
26479
26480 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26482 if (!SWIG_IsOK(res1)) {
26483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26484 }
26485 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26486 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26487 if (!SWIG_IsOK(res2)) {
26488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26489 }
26490 if (!argp2) {
26491 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26492 }
26493 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26494 {
26495 PyThreadState* __tstate = wxPyBeginAllowThreads();
26496 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26497 wxPyEndAllowThreads(__tstate);
26498 if (PyErr_Occurred()) SWIG_fail;
26499 }
26500 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26501 return resultobj;
26502 fail:
26503 return NULL;
26504 }
26505
26506
26507 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26508 PyObject *resultobj = 0;
26509 wxDateTime *arg1 = (wxDateTime *) 0 ;
26510 wxDateSpan *arg2 = 0 ;
26511 wxDateTime result;
26512 void *argp1 = 0 ;
26513 int res1 = 0 ;
26514 void *argp2 = 0 ;
26515 int res2 = 0 ;
26516
26517 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26519 if (!SWIG_IsOK(res1)) {
26520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26521 }
26522 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26523 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26524 if (!SWIG_IsOK(res2)) {
26525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26526 }
26527 if (!argp2) {
26528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26529 }
26530 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26531 {
26532 PyThreadState* __tstate = wxPyBeginAllowThreads();
26533 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26534 wxPyEndAllowThreads(__tstate);
26535 if (PyErr_Occurred()) SWIG_fail;
26536 }
26537 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26538 return resultobj;
26539 fail:
26540 return NULL;
26541 }
26542
26543
26544 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26545 int argc;
26546 PyObject *argv[3];
26547
26548 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26549 --argc;
26550 if (argc == 2) {
26551 int _v = 0;
26552 {
26553 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26554 _v = SWIG_CheckState(res);
26555 }
26556 if (!_v) goto check_1;
26557 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26558 }
26559 check_1:
26560
26561 if (argc == 2) {
26562 int _v = 0;
26563 {
26564 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26565 _v = SWIG_CheckState(res);
26566 }
26567 if (!_v) goto check_2;
26568 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26569 }
26570 check_2:
26571
26572 if (argc == 2) {
26573 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26574 }
26575
26576 fail:
26577 Py_INCREF(Py_NotImplemented);
26578 return Py_NotImplemented;
26579 }
26580
26581
26582 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26583 PyObject *resultobj = 0;
26584 wxDateTime *arg1 = (wxDateTime *) 0 ;
26585 wxDateTime *arg2 = (wxDateTime *) 0 ;
26586 bool result;
26587 void *argp1 = 0 ;
26588 int res1 = 0 ;
26589 void *argp2 = 0 ;
26590 int res2 = 0 ;
26591 PyObject * obj0 = 0 ;
26592 PyObject * obj1 = 0 ;
26593 char * kwnames[] = {
26594 (char *) "self",(char *) "other", NULL
26595 };
26596
26597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26599 if (!SWIG_IsOK(res1)) {
26600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26601 }
26602 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26604 if (!SWIG_IsOK(res2)) {
26605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26606 }
26607 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26608 {
26609 PyThreadState* __tstate = wxPyBeginAllowThreads();
26610 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 {
26615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26616 }
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj = 0;
26625 wxDateTime *arg1 = (wxDateTime *) 0 ;
26626 wxDateTime *arg2 = (wxDateTime *) 0 ;
26627 bool result;
26628 void *argp1 = 0 ;
26629 int res1 = 0 ;
26630 void *argp2 = 0 ;
26631 int res2 = 0 ;
26632 PyObject * obj0 = 0 ;
26633 PyObject * obj1 = 0 ;
26634 char * kwnames[] = {
26635 (char *) "self",(char *) "other", NULL
26636 };
26637
26638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26640 if (!SWIG_IsOK(res1)) {
26641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26642 }
26643 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26645 if (!SWIG_IsOK(res2)) {
26646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26647 }
26648 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 {
26656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26657 }
26658 return resultobj;
26659 fail:
26660 return NULL;
26661 }
26662
26663
26664 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26665 PyObject *resultobj = 0;
26666 wxDateTime *arg1 = (wxDateTime *) 0 ;
26667 wxDateTime *arg2 = (wxDateTime *) 0 ;
26668 bool result;
26669 void *argp1 = 0 ;
26670 int res1 = 0 ;
26671 void *argp2 = 0 ;
26672 int res2 = 0 ;
26673 PyObject * obj0 = 0 ;
26674 PyObject * obj1 = 0 ;
26675 char * kwnames[] = {
26676 (char *) "self",(char *) "other", NULL
26677 };
26678
26679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26681 if (!SWIG_IsOK(res1)) {
26682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26683 }
26684 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26686 if (!SWIG_IsOK(res2)) {
26687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26688 }
26689 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26690 {
26691 PyThreadState* __tstate = wxPyBeginAllowThreads();
26692 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26693 wxPyEndAllowThreads(__tstate);
26694 if (PyErr_Occurred()) SWIG_fail;
26695 }
26696 {
26697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26698 }
26699 return resultobj;
26700 fail:
26701 return NULL;
26702 }
26703
26704
26705 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26706 PyObject *resultobj = 0;
26707 wxDateTime *arg1 = (wxDateTime *) 0 ;
26708 wxDateTime *arg2 = (wxDateTime *) 0 ;
26709 bool result;
26710 void *argp1 = 0 ;
26711 int res1 = 0 ;
26712 void *argp2 = 0 ;
26713 int res2 = 0 ;
26714 PyObject * obj0 = 0 ;
26715 PyObject * obj1 = 0 ;
26716 char * kwnames[] = {
26717 (char *) "self",(char *) "other", NULL
26718 };
26719
26720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26722 if (!SWIG_IsOK(res1)) {
26723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26724 }
26725 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26727 if (!SWIG_IsOK(res2)) {
26728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26729 }
26730 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26734 wxPyEndAllowThreads(__tstate);
26735 if (PyErr_Occurred()) SWIG_fail;
26736 }
26737 {
26738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26739 }
26740 return resultobj;
26741 fail:
26742 return NULL;
26743 }
26744
26745
26746 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26747 PyObject *resultobj = 0;
26748 wxDateTime *arg1 = (wxDateTime *) 0 ;
26749 wxDateTime *arg2 = (wxDateTime *) 0 ;
26750 bool result;
26751 void *argp1 = 0 ;
26752 int res1 = 0 ;
26753 void *argp2 = 0 ;
26754 int res2 = 0 ;
26755 PyObject * obj0 = 0 ;
26756 PyObject * obj1 = 0 ;
26757 char * kwnames[] = {
26758 (char *) "self",(char *) "other", NULL
26759 };
26760
26761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26763 if (!SWIG_IsOK(res1)) {
26764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26765 }
26766 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26768 if (!SWIG_IsOK(res2)) {
26769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26770 }
26771 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26772 {
26773 PyThreadState* __tstate = wxPyBeginAllowThreads();
26774 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26775 wxPyEndAllowThreads(__tstate);
26776 if (PyErr_Occurred()) SWIG_fail;
26777 }
26778 {
26779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26780 }
26781 return resultobj;
26782 fail:
26783 return NULL;
26784 }
26785
26786
26787 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26788 PyObject *resultobj = 0;
26789 wxDateTime *arg1 = (wxDateTime *) 0 ;
26790 wxDateTime *arg2 = (wxDateTime *) 0 ;
26791 bool result;
26792 void *argp1 = 0 ;
26793 int res1 = 0 ;
26794 void *argp2 = 0 ;
26795 int res2 = 0 ;
26796 PyObject * obj0 = 0 ;
26797 PyObject * obj1 = 0 ;
26798 char * kwnames[] = {
26799 (char *) "self",(char *) "other", NULL
26800 };
26801
26802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26804 if (!SWIG_IsOK(res1)) {
26805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26806 }
26807 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26808 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26809 if (!SWIG_IsOK(res2)) {
26810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26811 }
26812 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26816 wxPyEndAllowThreads(__tstate);
26817 if (PyErr_Occurred()) SWIG_fail;
26818 }
26819 {
26820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26821 }
26822 return resultobj;
26823 fail:
26824 return NULL;
26825 }
26826
26827
26828 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26829 PyObject *resultobj = 0;
26830 wxDateTime *arg1 = (wxDateTime *) 0 ;
26831 wxString *arg2 = 0 ;
26832 int result;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 bool temp2 = false ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 char * kwnames[] = {
26839 (char *) "self",(char *) "date", NULL
26840 };
26841
26842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26844 if (!SWIG_IsOK(res1)) {
26845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26846 }
26847 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26848 {
26849 arg2 = wxString_in_helper(obj1);
26850 if (arg2 == NULL) SWIG_fail;
26851 temp2 = true;
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 resultobj = SWIG_From_int(static_cast< int >(result));
26860 {
26861 if (temp2)
26862 delete arg2;
26863 }
26864 return resultobj;
26865 fail:
26866 {
26867 if (temp2)
26868 delete arg2;
26869 }
26870 return NULL;
26871 }
26872
26873
26874 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26875 PyObject *resultobj = 0;
26876 wxDateTime *arg1 = (wxDateTime *) 0 ;
26877 wxString *arg2 = 0 ;
26878 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26879 wxString *arg3 = (wxString *) &arg3_defvalue ;
26880 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26881 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26882 int result;
26883 void *argp1 = 0 ;
26884 int res1 = 0 ;
26885 bool temp2 = false ;
26886 bool temp3 = false ;
26887 void *argp4 = 0 ;
26888 int res4 = 0 ;
26889 PyObject * obj0 = 0 ;
26890 PyObject * obj1 = 0 ;
26891 PyObject * obj2 = 0 ;
26892 PyObject * obj3 = 0 ;
26893 char * kwnames[] = {
26894 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26895 };
26896
26897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26899 if (!SWIG_IsOK(res1)) {
26900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26901 }
26902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26903 {
26904 arg2 = wxString_in_helper(obj1);
26905 if (arg2 == NULL) SWIG_fail;
26906 temp2 = true;
26907 }
26908 if (obj2) {
26909 {
26910 arg3 = wxString_in_helper(obj2);
26911 if (arg3 == NULL) SWIG_fail;
26912 temp3 = true;
26913 }
26914 }
26915 if (obj3) {
26916 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26917 if (!SWIG_IsOK(res4)) {
26918 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26919 }
26920 if (!argp4) {
26921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26922 }
26923 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26924 }
26925 {
26926 PyThreadState* __tstate = wxPyBeginAllowThreads();
26927 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26928 wxPyEndAllowThreads(__tstate);
26929 if (PyErr_Occurred()) SWIG_fail;
26930 }
26931 resultobj = SWIG_From_int(static_cast< int >(result));
26932 {
26933 if (temp2)
26934 delete arg2;
26935 }
26936 {
26937 if (temp3)
26938 delete arg3;
26939 }
26940 return resultobj;
26941 fail:
26942 {
26943 if (temp2)
26944 delete arg2;
26945 }
26946 {
26947 if (temp3)
26948 delete arg3;
26949 }
26950 return NULL;
26951 }
26952
26953
26954 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26955 PyObject *resultobj = 0;
26956 wxDateTime *arg1 = (wxDateTime *) 0 ;
26957 wxString *arg2 = 0 ;
26958 int result;
26959 void *argp1 = 0 ;
26960 int res1 = 0 ;
26961 bool temp2 = false ;
26962 PyObject * obj0 = 0 ;
26963 PyObject * obj1 = 0 ;
26964 char * kwnames[] = {
26965 (char *) "self",(char *) "datetime", NULL
26966 };
26967
26968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26970 if (!SWIG_IsOK(res1)) {
26971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26972 }
26973 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26974 {
26975 arg2 = wxString_in_helper(obj1);
26976 if (arg2 == NULL) SWIG_fail;
26977 temp2 = true;
26978 }
26979 {
26980 PyThreadState* __tstate = wxPyBeginAllowThreads();
26981 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26982 wxPyEndAllowThreads(__tstate);
26983 if (PyErr_Occurred()) SWIG_fail;
26984 }
26985 resultobj = SWIG_From_int(static_cast< int >(result));
26986 {
26987 if (temp2)
26988 delete arg2;
26989 }
26990 return resultobj;
26991 fail:
26992 {
26993 if (temp2)
26994 delete arg2;
26995 }
26996 return NULL;
26997 }
26998
26999
27000 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27001 PyObject *resultobj = 0;
27002 wxDateTime *arg1 = (wxDateTime *) 0 ;
27003 wxString *arg2 = 0 ;
27004 int result;
27005 void *argp1 = 0 ;
27006 int res1 = 0 ;
27007 bool temp2 = false ;
27008 PyObject * obj0 = 0 ;
27009 PyObject * obj1 = 0 ;
27010 char * kwnames[] = {
27011 (char *) "self",(char *) "date", NULL
27012 };
27013
27014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27016 if (!SWIG_IsOK(res1)) {
27017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27018 }
27019 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27020 {
27021 arg2 = wxString_in_helper(obj1);
27022 if (arg2 == NULL) SWIG_fail;
27023 temp2 = true;
27024 }
27025 {
27026 PyThreadState* __tstate = wxPyBeginAllowThreads();
27027 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27028 wxPyEndAllowThreads(__tstate);
27029 if (PyErr_Occurred()) SWIG_fail;
27030 }
27031 resultobj = SWIG_From_int(static_cast< int >(result));
27032 {
27033 if (temp2)
27034 delete arg2;
27035 }
27036 return resultobj;
27037 fail:
27038 {
27039 if (temp2)
27040 delete arg2;
27041 }
27042 return NULL;
27043 }
27044
27045
27046 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27047 PyObject *resultobj = 0;
27048 wxDateTime *arg1 = (wxDateTime *) 0 ;
27049 wxString *arg2 = 0 ;
27050 int result;
27051 void *argp1 = 0 ;
27052 int res1 = 0 ;
27053 bool temp2 = false ;
27054 PyObject * obj0 = 0 ;
27055 PyObject * obj1 = 0 ;
27056 char * kwnames[] = {
27057 (char *) "self",(char *) "time", NULL
27058 };
27059
27060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27062 if (!SWIG_IsOK(res1)) {
27063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27064 }
27065 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27066 {
27067 arg2 = wxString_in_helper(obj1);
27068 if (arg2 == NULL) SWIG_fail;
27069 temp2 = true;
27070 }
27071 {
27072 PyThreadState* __tstate = wxPyBeginAllowThreads();
27073 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27074 wxPyEndAllowThreads(__tstate);
27075 if (PyErr_Occurred()) SWIG_fail;
27076 }
27077 resultobj = SWIG_From_int(static_cast< int >(result));
27078 {
27079 if (temp2)
27080 delete arg2;
27081 }
27082 return resultobj;
27083 fail:
27084 {
27085 if (temp2)
27086 delete arg2;
27087 }
27088 return NULL;
27089 }
27090
27091
27092 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj = 0;
27094 wxDateTime *arg1 = (wxDateTime *) 0 ;
27095 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27096 wxString *arg2 = (wxString *) &arg2_defvalue ;
27097 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27098 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27099 wxString result;
27100 void *argp1 = 0 ;
27101 int res1 = 0 ;
27102 bool temp2 = false ;
27103 bool temp3 = false ;
27104 PyObject * obj0 = 0 ;
27105 PyObject * obj1 = 0 ;
27106 PyObject * obj2 = 0 ;
27107 char * kwnames[] = {
27108 (char *) "self",(char *) "format",(char *) "tz", NULL
27109 };
27110
27111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27113 if (!SWIG_IsOK(res1)) {
27114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27115 }
27116 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27117 if (obj1) {
27118 {
27119 arg2 = wxString_in_helper(obj1);
27120 if (arg2 == NULL) SWIG_fail;
27121 temp2 = true;
27122 }
27123 }
27124 if (obj2) {
27125 {
27126 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27127 temp3 = true;
27128 }
27129 }
27130 {
27131 PyThreadState* __tstate = wxPyBeginAllowThreads();
27132 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 {
27137 #if wxUSE_UNICODE
27138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27139 #else
27140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27141 #endif
27142 }
27143 {
27144 if (temp2)
27145 delete arg2;
27146 }
27147 {
27148 if (temp3) delete arg3;
27149 }
27150 return resultobj;
27151 fail:
27152 {
27153 if (temp2)
27154 delete arg2;
27155 }
27156 {
27157 if (temp3) delete arg3;
27158 }
27159 return NULL;
27160 }
27161
27162
27163 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27164 PyObject *resultobj = 0;
27165 wxDateTime *arg1 = (wxDateTime *) 0 ;
27166 wxString result;
27167 void *argp1 = 0 ;
27168 int res1 = 0 ;
27169 PyObject *swig_obj[1] ;
27170
27171 if (!args) SWIG_fail;
27172 swig_obj[0] = args;
27173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27174 if (!SWIG_IsOK(res1)) {
27175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27176 }
27177 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 result = ((wxDateTime const *)arg1)->FormatDate();
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 {
27185 #if wxUSE_UNICODE
27186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27187 #else
27188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27189 #endif
27190 }
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27198 PyObject *resultobj = 0;
27199 wxDateTime *arg1 = (wxDateTime *) 0 ;
27200 wxString result;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 PyObject *swig_obj[1] ;
27204
27205 if (!args) SWIG_fail;
27206 swig_obj[0] = args;
27207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27208 if (!SWIG_IsOK(res1)) {
27209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27210 }
27211 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 result = ((wxDateTime const *)arg1)->FormatTime();
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 {
27219 #if wxUSE_UNICODE
27220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27221 #else
27222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27223 #endif
27224 }
27225 return resultobj;
27226 fail:
27227 return NULL;
27228 }
27229
27230
27231 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27232 PyObject *resultobj = 0;
27233 wxDateTime *arg1 = (wxDateTime *) 0 ;
27234 wxString result;
27235 void *argp1 = 0 ;
27236 int res1 = 0 ;
27237 PyObject *swig_obj[1] ;
27238
27239 if (!args) SWIG_fail;
27240 swig_obj[0] = args;
27241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27242 if (!SWIG_IsOK(res1)) {
27243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27244 }
27245 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27246 {
27247 PyThreadState* __tstate = wxPyBeginAllowThreads();
27248 result = ((wxDateTime const *)arg1)->FormatISODate();
27249 wxPyEndAllowThreads(__tstate);
27250 if (PyErr_Occurred()) SWIG_fail;
27251 }
27252 {
27253 #if wxUSE_UNICODE
27254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27255 #else
27256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27257 #endif
27258 }
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27266 PyObject *resultobj = 0;
27267 wxDateTime *arg1 = (wxDateTime *) 0 ;
27268 wxString result;
27269 void *argp1 = 0 ;
27270 int res1 = 0 ;
27271 PyObject *swig_obj[1] ;
27272
27273 if (!args) SWIG_fail;
27274 swig_obj[0] = args;
27275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27276 if (!SWIG_IsOK(res1)) {
27277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27278 }
27279 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 result = ((wxDateTime const *)arg1)->FormatISOTime();
27283 wxPyEndAllowThreads(__tstate);
27284 if (PyErr_Occurred()) SWIG_fail;
27285 }
27286 {
27287 #if wxUSE_UNICODE
27288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27289 #else
27290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27291 #endif
27292 }
27293 return resultobj;
27294 fail:
27295 return NULL;
27296 }
27297
27298
27299 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27300 PyObject *obj;
27301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27302 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27303 return SWIG_Py_Void();
27304 }
27305
27306 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27307 return SWIG_Python_InitShadowInstance(args);
27308 }
27309
27310 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27311 PyObject *resultobj = 0;
27312 long arg1 ;
27313 wxTimeSpan result;
27314 long val1 ;
27315 int ecode1 = 0 ;
27316 PyObject * obj0 = 0 ;
27317 char * kwnames[] = {
27318 (char *) "sec", NULL
27319 };
27320
27321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27322 ecode1 = SWIG_AsVal_long(obj0, &val1);
27323 if (!SWIG_IsOK(ecode1)) {
27324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27325 }
27326 arg1 = static_cast< long >(val1);
27327 {
27328 PyThreadState* __tstate = wxPyBeginAllowThreads();
27329 result = wxTimeSpan::Seconds(arg1);
27330 wxPyEndAllowThreads(__tstate);
27331 if (PyErr_Occurred()) SWIG_fail;
27332 }
27333 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27334 return resultobj;
27335 fail:
27336 return NULL;
27337 }
27338
27339
27340 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27341 PyObject *resultobj = 0;
27342 wxTimeSpan result;
27343
27344 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27345 {
27346 PyThreadState* __tstate = wxPyBeginAllowThreads();
27347 result = wxTimeSpan::Second();
27348 wxPyEndAllowThreads(__tstate);
27349 if (PyErr_Occurred()) SWIG_fail;
27350 }
27351 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27352 return resultobj;
27353 fail:
27354 return NULL;
27355 }
27356
27357
27358 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27359 PyObject *resultobj = 0;
27360 long arg1 ;
27361 wxTimeSpan result;
27362 long val1 ;
27363 int ecode1 = 0 ;
27364 PyObject * obj0 = 0 ;
27365 char * kwnames[] = {
27366 (char *) "min", NULL
27367 };
27368
27369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27370 ecode1 = SWIG_AsVal_long(obj0, &val1);
27371 if (!SWIG_IsOK(ecode1)) {
27372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27373 }
27374 arg1 = static_cast< long >(val1);
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 result = wxTimeSpan::Minutes(arg1);
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27389 PyObject *resultobj = 0;
27390 wxTimeSpan result;
27391
27392 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27393 {
27394 PyThreadState* __tstate = wxPyBeginAllowThreads();
27395 result = wxTimeSpan::Minute();
27396 wxPyEndAllowThreads(__tstate);
27397 if (PyErr_Occurred()) SWIG_fail;
27398 }
27399 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27400 return resultobj;
27401 fail:
27402 return NULL;
27403 }
27404
27405
27406 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27407 PyObject *resultobj = 0;
27408 long arg1 ;
27409 wxTimeSpan result;
27410 long val1 ;
27411 int ecode1 = 0 ;
27412 PyObject * obj0 = 0 ;
27413 char * kwnames[] = {
27414 (char *) "hours", NULL
27415 };
27416
27417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27418 ecode1 = SWIG_AsVal_long(obj0, &val1);
27419 if (!SWIG_IsOK(ecode1)) {
27420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27421 }
27422 arg1 = static_cast< long >(val1);
27423 {
27424 PyThreadState* __tstate = wxPyBeginAllowThreads();
27425 result = wxTimeSpan::Hours(arg1);
27426 wxPyEndAllowThreads(__tstate);
27427 if (PyErr_Occurred()) SWIG_fail;
27428 }
27429 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27430 return resultobj;
27431 fail:
27432 return NULL;
27433 }
27434
27435
27436 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27437 PyObject *resultobj = 0;
27438 wxTimeSpan result;
27439
27440 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 result = wxTimeSpan::Hour();
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27455 PyObject *resultobj = 0;
27456 long arg1 ;
27457 wxTimeSpan result;
27458 long val1 ;
27459 int ecode1 = 0 ;
27460 PyObject * obj0 = 0 ;
27461 char * kwnames[] = {
27462 (char *) "days", NULL
27463 };
27464
27465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27466 ecode1 = SWIG_AsVal_long(obj0, &val1);
27467 if (!SWIG_IsOK(ecode1)) {
27468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27469 }
27470 arg1 = static_cast< long >(val1);
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 result = wxTimeSpan::Days(arg1);
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27485 PyObject *resultobj = 0;
27486 wxTimeSpan result;
27487
27488 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27489 {
27490 PyThreadState* __tstate = wxPyBeginAllowThreads();
27491 result = wxTimeSpan::Day();
27492 wxPyEndAllowThreads(__tstate);
27493 if (PyErr_Occurred()) SWIG_fail;
27494 }
27495 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27496 return resultobj;
27497 fail:
27498 return NULL;
27499 }
27500
27501
27502 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27503 PyObject *resultobj = 0;
27504 long arg1 ;
27505 wxTimeSpan result;
27506 long val1 ;
27507 int ecode1 = 0 ;
27508 PyObject * obj0 = 0 ;
27509 char * kwnames[] = {
27510 (char *) "days", NULL
27511 };
27512
27513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27514 ecode1 = SWIG_AsVal_long(obj0, &val1);
27515 if (!SWIG_IsOK(ecode1)) {
27516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27517 }
27518 arg1 = static_cast< long >(val1);
27519 {
27520 PyThreadState* __tstate = wxPyBeginAllowThreads();
27521 result = wxTimeSpan::Weeks(arg1);
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27533 PyObject *resultobj = 0;
27534 wxTimeSpan result;
27535
27536 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 result = wxTimeSpan::Week();
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27551 PyObject *resultobj = 0;
27552 long arg1 = (long) 0 ;
27553 long arg2 = (long) 0 ;
27554 long arg3 = (long) 0 ;
27555 long arg4 = (long) 0 ;
27556 wxTimeSpan *result = 0 ;
27557 long val1 ;
27558 int ecode1 = 0 ;
27559 long val2 ;
27560 int ecode2 = 0 ;
27561 long val3 ;
27562 int ecode3 = 0 ;
27563 long val4 ;
27564 int ecode4 = 0 ;
27565 PyObject * obj0 = 0 ;
27566 PyObject * obj1 = 0 ;
27567 PyObject * obj2 = 0 ;
27568 PyObject * obj3 = 0 ;
27569 char * kwnames[] = {
27570 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27571 };
27572
27573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27574 if (obj0) {
27575 ecode1 = SWIG_AsVal_long(obj0, &val1);
27576 if (!SWIG_IsOK(ecode1)) {
27577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27578 }
27579 arg1 = static_cast< long >(val1);
27580 }
27581 if (obj1) {
27582 ecode2 = SWIG_AsVal_long(obj1, &val2);
27583 if (!SWIG_IsOK(ecode2)) {
27584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27585 }
27586 arg2 = static_cast< long >(val2);
27587 }
27588 if (obj2) {
27589 ecode3 = SWIG_AsVal_long(obj2, &val3);
27590 if (!SWIG_IsOK(ecode3)) {
27591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27592 }
27593 arg3 = static_cast< long >(val3);
27594 }
27595 if (obj3) {
27596 ecode4 = SWIG_AsVal_long(obj3, &val4);
27597 if (!SWIG_IsOK(ecode4)) {
27598 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27599 }
27600 arg4 = static_cast< long >(val4);
27601 }
27602 {
27603 PyThreadState* __tstate = wxPyBeginAllowThreads();
27604 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27609 return resultobj;
27610 fail:
27611 return NULL;
27612 }
27613
27614
27615 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27616 PyObject *resultobj = 0;
27617 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27618 void *argp1 = 0 ;
27619 int res1 = 0 ;
27620 PyObject *swig_obj[1] ;
27621
27622 if (!args) SWIG_fail;
27623 swig_obj[0] = args;
27624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27625 if (!SWIG_IsOK(res1)) {
27626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27627 }
27628 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 delete arg1;
27632
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 resultobj = SWIG_Py_Void();
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27644 PyObject *resultobj = 0;
27645 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27646 wxTimeSpan *arg2 = 0 ;
27647 wxTimeSpan *result = 0 ;
27648 void *argp1 = 0 ;
27649 int res1 = 0 ;
27650 void *argp2 = 0 ;
27651 int res2 = 0 ;
27652 PyObject * obj0 = 0 ;
27653 PyObject * obj1 = 0 ;
27654 char * kwnames[] = {
27655 (char *) "self",(char *) "diff", NULL
27656 };
27657
27658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27660 if (!SWIG_IsOK(res1)) {
27661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27662 }
27663 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27664 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27665 if (!SWIG_IsOK(res2)) {
27666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27667 }
27668 if (!argp2) {
27669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27670 }
27671 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27672 {
27673 PyThreadState* __tstate = wxPyBeginAllowThreads();
27674 {
27675 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27676 result = (wxTimeSpan *) &_result_ref;
27677 }
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27689 PyObject *resultobj = 0;
27690 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27691 wxTimeSpan *arg2 = 0 ;
27692 wxTimeSpan *result = 0 ;
27693 void *argp1 = 0 ;
27694 int res1 = 0 ;
27695 void *argp2 = 0 ;
27696 int res2 = 0 ;
27697 PyObject * obj0 = 0 ;
27698 PyObject * obj1 = 0 ;
27699 char * kwnames[] = {
27700 (char *) "self",(char *) "diff", NULL
27701 };
27702
27703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27705 if (!SWIG_IsOK(res1)) {
27706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27707 }
27708 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27710 if (!SWIG_IsOK(res2)) {
27711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27712 }
27713 if (!argp2) {
27714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27715 }
27716 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 {
27720 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27721 result = (wxTimeSpan *) &_result_ref;
27722 }
27723 wxPyEndAllowThreads(__tstate);
27724 if (PyErr_Occurred()) SWIG_fail;
27725 }
27726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27727 return resultobj;
27728 fail:
27729 return NULL;
27730 }
27731
27732
27733 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27734 PyObject *resultobj = 0;
27735 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27736 int arg2 ;
27737 wxTimeSpan *result = 0 ;
27738 void *argp1 = 0 ;
27739 int res1 = 0 ;
27740 int val2 ;
27741 int ecode2 = 0 ;
27742 PyObject * obj0 = 0 ;
27743 PyObject * obj1 = 0 ;
27744 char * kwnames[] = {
27745 (char *) "self",(char *) "n", NULL
27746 };
27747
27748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27750 if (!SWIG_IsOK(res1)) {
27751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27752 }
27753 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27754 ecode2 = SWIG_AsVal_int(obj1, &val2);
27755 if (!SWIG_IsOK(ecode2)) {
27756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27757 }
27758 arg2 = static_cast< int >(val2);
27759 {
27760 PyThreadState* __tstate = wxPyBeginAllowThreads();
27761 {
27762 wxTimeSpan &_result_ref = (arg1)->Multiply(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_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27776 PyObject *resultobj = 0;
27777 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27778 wxTimeSpan *result = 0 ;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 PyObject *swig_obj[1] ;
27782
27783 if (!args) SWIG_fail;
27784 swig_obj[0] = args;
27785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27786 if (!SWIG_IsOK(res1)) {
27787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27788 }
27789 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 {
27793 wxTimeSpan &_result_ref = (arg1)->Neg();
27794 result = (wxTimeSpan *) &_result_ref;
27795 }
27796 wxPyEndAllowThreads(__tstate);
27797 if (PyErr_Occurred()) SWIG_fail;
27798 }
27799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27800 return resultobj;
27801 fail:
27802 return NULL;
27803 }
27804
27805
27806 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27807 PyObject *resultobj = 0;
27808 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27809 wxTimeSpan result;
27810 void *argp1 = 0 ;
27811 int res1 = 0 ;
27812 PyObject *swig_obj[1] ;
27813
27814 if (!args) SWIG_fail;
27815 swig_obj[0] = args;
27816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27817 if (!SWIG_IsOK(res1)) {
27818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27819 }
27820 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27821 {
27822 PyThreadState* __tstate = wxPyBeginAllowThreads();
27823 result = ((wxTimeSpan const *)arg1)->Abs();
27824 wxPyEndAllowThreads(__tstate);
27825 if (PyErr_Occurred()) SWIG_fail;
27826 }
27827 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27828 return resultobj;
27829 fail:
27830 return NULL;
27831 }
27832
27833
27834 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27835 PyObject *resultobj = 0;
27836 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27837 wxTimeSpan *arg2 = 0 ;
27838 wxTimeSpan *result = 0 ;
27839 void *argp1 = 0 ;
27840 int res1 = 0 ;
27841 void *argp2 = 0 ;
27842 int res2 = 0 ;
27843 PyObject * obj0 = 0 ;
27844 PyObject * obj1 = 0 ;
27845 char * kwnames[] = {
27846 (char *) "self",(char *) "diff", NULL
27847 };
27848
27849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27851 if (!SWIG_IsOK(res1)) {
27852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27853 }
27854 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27855 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27856 if (!SWIG_IsOK(res2)) {
27857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27858 }
27859 if (!argp2) {
27860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27861 }
27862 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27863 {
27864 PyThreadState* __tstate = wxPyBeginAllowThreads();
27865 {
27866 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27867 result = (wxTimeSpan *) &_result_ref;
27868 }
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27873 return resultobj;
27874 fail:
27875 return NULL;
27876 }
27877
27878
27879 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27880 PyObject *resultobj = 0;
27881 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27882 wxTimeSpan *arg2 = 0 ;
27883 wxTimeSpan *result = 0 ;
27884 void *argp1 = 0 ;
27885 int res1 = 0 ;
27886 void *argp2 = 0 ;
27887 int res2 = 0 ;
27888 PyObject * obj0 = 0 ;
27889 PyObject * obj1 = 0 ;
27890 char * kwnames[] = {
27891 (char *) "self",(char *) "diff", NULL
27892 };
27893
27894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27898 }
27899 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27900 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27901 if (!SWIG_IsOK(res2)) {
27902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27903 }
27904 if (!argp2) {
27905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27906 }
27907 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27908 {
27909 PyThreadState* __tstate = wxPyBeginAllowThreads();
27910 {
27911 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27912 result = (wxTimeSpan *) &_result_ref;
27913 }
27914 wxPyEndAllowThreads(__tstate);
27915 if (PyErr_Occurred()) SWIG_fail;
27916 }
27917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27918 return resultobj;
27919 fail:
27920 return NULL;
27921 }
27922
27923
27924 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27925 PyObject *resultobj = 0;
27926 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27927 int arg2 ;
27928 wxTimeSpan *result = 0 ;
27929 void *argp1 = 0 ;
27930 int res1 = 0 ;
27931 int val2 ;
27932 int ecode2 = 0 ;
27933 PyObject * obj0 = 0 ;
27934 PyObject * obj1 = 0 ;
27935 char * kwnames[] = {
27936 (char *) "self",(char *) "n", NULL
27937 };
27938
27939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27941 if (!SWIG_IsOK(res1)) {
27942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27943 }
27944 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27945 ecode2 = SWIG_AsVal_int(obj1, &val2);
27946 if (!SWIG_IsOK(ecode2)) {
27947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
27948 }
27949 arg2 = static_cast< int >(val2);
27950 {
27951 PyThreadState* __tstate = wxPyBeginAllowThreads();
27952 {
27953 wxTimeSpan &_result_ref = (arg1)->operator *=(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___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27967 PyObject *resultobj = 0;
27968 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27969 wxTimeSpan *result = 0 ;
27970 void *argp1 = 0 ;
27971 int res1 = 0 ;
27972 PyObject *swig_obj[1] ;
27973
27974 if (!args) SWIG_fail;
27975 swig_obj[0] = args;
27976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27977 if (!SWIG_IsOK(res1)) {
27978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27979 }
27980 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27981 {
27982 PyThreadState* __tstate = wxPyBeginAllowThreads();
27983 {
27984 wxTimeSpan &_result_ref = (arg1)->operator -();
27985 result = (wxTimeSpan *) &_result_ref;
27986 }
27987 wxPyEndAllowThreads(__tstate);
27988 if (PyErr_Occurred()) SWIG_fail;
27989 }
27990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27991 return resultobj;
27992 fail:
27993 return NULL;
27994 }
27995
27996
27997 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj = 0;
27999 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28000 wxTimeSpan *arg2 = 0 ;
28001 wxTimeSpan result;
28002 void *argp1 = 0 ;
28003 int res1 = 0 ;
28004 void *argp2 = 0 ;
28005 int res2 = 0 ;
28006 PyObject * obj0 = 0 ;
28007 PyObject * obj1 = 0 ;
28008 char * kwnames[] = {
28009 (char *) "self",(char *) "other", NULL
28010 };
28011
28012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28014 if (!SWIG_IsOK(res1)) {
28015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28016 }
28017 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28018 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28019 if (!SWIG_IsOK(res2)) {
28020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28021 }
28022 if (!argp2) {
28023 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28024 }
28025 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(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___sub__",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___sub__" "', 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___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28063 }
28064 if (!argp2) {
28065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28066 }
28067 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 result = wxTimeSpan___sub__(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___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28082 PyObject *resultobj = 0;
28083 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28084 int arg2 ;
28085 wxTimeSpan result;
28086 void *argp1 = 0 ;
28087 int res1 = 0 ;
28088 int val2 ;
28089 int ecode2 = 0 ;
28090 PyObject * obj0 = 0 ;
28091 PyObject * obj1 = 0 ;
28092 char * kwnames[] = {
28093 (char *) "self",(char *) "n", NULL
28094 };
28095
28096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",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___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28100 }
28101 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28102 ecode2 = SWIG_AsVal_int(obj1, &val2);
28103 if (!SWIG_IsOK(ecode2)) {
28104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28105 }
28106 arg2 = static_cast< int >(val2);
28107 {
28108 PyThreadState* __tstate = wxPyBeginAllowThreads();
28109 result = wxTimeSpan___mul__(arg1,arg2);
28110 wxPyEndAllowThreads(__tstate);
28111 if (PyErr_Occurred()) SWIG_fail;
28112 }
28113 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28121 PyObject *resultobj = 0;
28122 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28123 int arg2 ;
28124 wxTimeSpan result;
28125 void *argp1 = 0 ;
28126 int res1 = 0 ;
28127 int val2 ;
28128 int ecode2 = 0 ;
28129 PyObject * obj0 = 0 ;
28130 PyObject * obj1 = 0 ;
28131 char * kwnames[] = {
28132 (char *) "self",(char *) "n", NULL
28133 };
28134
28135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28137 if (!SWIG_IsOK(res1)) {
28138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28139 }
28140 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28141 ecode2 = SWIG_AsVal_int(obj1, &val2);
28142 if (!SWIG_IsOK(ecode2)) {
28143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28144 }
28145 arg2 = static_cast< int >(val2);
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 result = wxTimeSpan___rmul__(arg1,arg2);
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28160 PyObject *resultobj = 0;
28161 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28162 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28163 bool result;
28164 void *argp1 = 0 ;
28165 int res1 = 0 ;
28166 void *argp2 = 0 ;
28167 int res2 = 0 ;
28168 PyObject * obj0 = 0 ;
28169 PyObject * obj1 = 0 ;
28170 char * kwnames[] = {
28171 (char *) "self",(char *) "other", NULL
28172 };
28173
28174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28176 if (!SWIG_IsOK(res1)) {
28177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28178 }
28179 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28181 if (!SWIG_IsOK(res2)) {
28182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28183 }
28184 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28188 wxPyEndAllowThreads(__tstate);
28189 if (PyErr_Occurred()) SWIG_fail;
28190 }
28191 {
28192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28193 }
28194 return resultobj;
28195 fail:
28196 return NULL;
28197 }
28198
28199
28200 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28201 PyObject *resultobj = 0;
28202 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28203 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28204 bool result;
28205 void *argp1 = 0 ;
28206 int res1 = 0 ;
28207 void *argp2 = 0 ;
28208 int res2 = 0 ;
28209 PyObject * obj0 = 0 ;
28210 PyObject * obj1 = 0 ;
28211 char * kwnames[] = {
28212 (char *) "self",(char *) "other", NULL
28213 };
28214
28215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28217 if (!SWIG_IsOK(res1)) {
28218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28219 }
28220 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28222 if (!SWIG_IsOK(res2)) {
28223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28224 }
28225 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 {
28233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28234 }
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28242 PyObject *resultobj = 0;
28243 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28244 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28245 bool result;
28246 void *argp1 = 0 ;
28247 int res1 = 0 ;
28248 void *argp2 = 0 ;
28249 int res2 = 0 ;
28250 PyObject * obj0 = 0 ;
28251 PyObject * obj1 = 0 ;
28252 char * kwnames[] = {
28253 (char *) "self",(char *) "other", NULL
28254 };
28255
28256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28258 if (!SWIG_IsOK(res1)) {
28259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28260 }
28261 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28263 if (!SWIG_IsOK(res2)) {
28264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28265 }
28266 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 {
28274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28275 }
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28285 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28286 bool result;
28287 void *argp1 = 0 ;
28288 int res1 = 0 ;
28289 void *argp2 = 0 ;
28290 int res2 = 0 ;
28291 PyObject * obj0 = 0 ;
28292 PyObject * obj1 = 0 ;
28293 char * kwnames[] = {
28294 (char *) "self",(char *) "other", NULL
28295 };
28296
28297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28299 if (!SWIG_IsOK(res1)) {
28300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28301 }
28302 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28304 if (!SWIG_IsOK(res2)) {
28305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28306 }
28307 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28311 wxPyEndAllowThreads(__tstate);
28312 if (PyErr_Occurred()) SWIG_fail;
28313 }
28314 {
28315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28316 }
28317 return resultobj;
28318 fail:
28319 return NULL;
28320 }
28321
28322
28323 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28324 PyObject *resultobj = 0;
28325 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28326 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28327 bool result;
28328 void *argp1 = 0 ;
28329 int res1 = 0 ;
28330 void *argp2 = 0 ;
28331 int res2 = 0 ;
28332 PyObject * obj0 = 0 ;
28333 PyObject * obj1 = 0 ;
28334 char * kwnames[] = {
28335 (char *) "self",(char *) "other", NULL
28336 };
28337
28338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28340 if (!SWIG_IsOK(res1)) {
28341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28342 }
28343 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28345 if (!SWIG_IsOK(res2)) {
28346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28347 }
28348 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 {
28356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28357 }
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = 0;
28366 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28367 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28368 bool result;
28369 void *argp1 = 0 ;
28370 int res1 = 0 ;
28371 void *argp2 = 0 ;
28372 int res2 = 0 ;
28373 PyObject * obj0 = 0 ;
28374 PyObject * obj1 = 0 ;
28375 char * kwnames[] = {
28376 (char *) "self",(char *) "other", NULL
28377 };
28378
28379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28381 if (!SWIG_IsOK(res1)) {
28382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28383 }
28384 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28385 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28386 if (!SWIG_IsOK(res2)) {
28387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28388 }
28389 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28390 {
28391 PyThreadState* __tstate = wxPyBeginAllowThreads();
28392 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28393 wxPyEndAllowThreads(__tstate);
28394 if (PyErr_Occurred()) SWIG_fail;
28395 }
28396 {
28397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28398 }
28399 return resultobj;
28400 fail:
28401 return NULL;
28402 }
28403
28404
28405 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28406 PyObject *resultobj = 0;
28407 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28408 bool result;
28409 void *argp1 = 0 ;
28410 int res1 = 0 ;
28411 PyObject *swig_obj[1] ;
28412
28413 if (!args) SWIG_fail;
28414 swig_obj[0] = args;
28415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28416 if (!SWIG_IsOK(res1)) {
28417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28418 }
28419 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28420 {
28421 PyThreadState* __tstate = wxPyBeginAllowThreads();
28422 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28423 wxPyEndAllowThreads(__tstate);
28424 if (PyErr_Occurred()) SWIG_fail;
28425 }
28426 {
28427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28428 }
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28436 PyObject *resultobj = 0;
28437 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28438 bool result;
28439 void *argp1 = 0 ;
28440 int res1 = 0 ;
28441 PyObject *swig_obj[1] ;
28442
28443 if (!args) SWIG_fail;
28444 swig_obj[0] = args;
28445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28446 if (!SWIG_IsOK(res1)) {
28447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28448 }
28449 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 {
28457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28458 }
28459 return resultobj;
28460 fail:
28461 return NULL;
28462 }
28463
28464
28465 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28466 PyObject *resultobj = 0;
28467 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28468 bool result;
28469 void *argp1 = 0 ;
28470 int res1 = 0 ;
28471 PyObject *swig_obj[1] ;
28472
28473 if (!args) SWIG_fail;
28474 swig_obj[0] = args;
28475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28476 if (!SWIG_IsOK(res1)) {
28477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28478 }
28479 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28480 {
28481 PyThreadState* __tstate = wxPyBeginAllowThreads();
28482 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 {
28487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28488 }
28489 return resultobj;
28490 fail:
28491 return NULL;
28492 }
28493
28494
28495 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28496 PyObject *resultobj = 0;
28497 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28498 wxTimeSpan *arg2 = 0 ;
28499 bool result;
28500 void *argp1 = 0 ;
28501 int res1 = 0 ;
28502 void *argp2 = 0 ;
28503 int res2 = 0 ;
28504 PyObject * obj0 = 0 ;
28505 PyObject * obj1 = 0 ;
28506 char * kwnames[] = {
28507 (char *) "self",(char *) "ts", NULL
28508 };
28509
28510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28512 if (!SWIG_IsOK(res1)) {
28513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28514 }
28515 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28516 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28517 if (!SWIG_IsOK(res2)) {
28518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28519 }
28520 if (!argp2) {
28521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28522 }
28523 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 {
28531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28532 }
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28540 PyObject *resultobj = 0;
28541 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28542 wxTimeSpan *arg2 = 0 ;
28543 bool result;
28544 void *argp1 = 0 ;
28545 int res1 = 0 ;
28546 void *argp2 = 0 ;
28547 int res2 = 0 ;
28548 PyObject * obj0 = 0 ;
28549 PyObject * obj1 = 0 ;
28550 char * kwnames[] = {
28551 (char *) "self",(char *) "ts", NULL
28552 };
28553
28554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28556 if (!SWIG_IsOK(res1)) {
28557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28558 }
28559 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28561 if (!SWIG_IsOK(res2)) {
28562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28563 }
28564 if (!argp2) {
28565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28566 }
28567 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28568 {
28569 PyThreadState* __tstate = wxPyBeginAllowThreads();
28570 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28571 wxPyEndAllowThreads(__tstate);
28572 if (PyErr_Occurred()) SWIG_fail;
28573 }
28574 {
28575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28576 }
28577 return resultobj;
28578 fail:
28579 return NULL;
28580 }
28581
28582
28583 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj = 0;
28585 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28586 wxTimeSpan *arg2 = 0 ;
28587 bool result;
28588 void *argp1 = 0 ;
28589 int res1 = 0 ;
28590 void *argp2 = 0 ;
28591 int res2 = 0 ;
28592 PyObject * obj0 = 0 ;
28593 PyObject * obj1 = 0 ;
28594 char * kwnames[] = {
28595 (char *) "self",(char *) "t", NULL
28596 };
28597
28598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28600 if (!SWIG_IsOK(res1)) {
28601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28602 }
28603 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28605 if (!SWIG_IsOK(res2)) {
28606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28607 }
28608 if (!argp2) {
28609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28610 }
28611 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 {
28619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28620 }
28621 return resultobj;
28622 fail:
28623 return NULL;
28624 }
28625
28626
28627 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28628 PyObject *resultobj = 0;
28629 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28630 int result;
28631 void *argp1 = 0 ;
28632 int res1 = 0 ;
28633 PyObject *swig_obj[1] ;
28634
28635 if (!args) SWIG_fail;
28636 swig_obj[0] = args;
28637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28638 if (!SWIG_IsOK(res1)) {
28639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28640 }
28641 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28642 {
28643 PyThreadState* __tstate = wxPyBeginAllowThreads();
28644 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28645 wxPyEndAllowThreads(__tstate);
28646 if (PyErr_Occurred()) SWIG_fail;
28647 }
28648 resultobj = SWIG_From_int(static_cast< int >(result));
28649 return resultobj;
28650 fail:
28651 return NULL;
28652 }
28653
28654
28655 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28656 PyObject *resultobj = 0;
28657 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28658 int result;
28659 void *argp1 = 0 ;
28660 int res1 = 0 ;
28661 PyObject *swig_obj[1] ;
28662
28663 if (!args) SWIG_fail;
28664 swig_obj[0] = args;
28665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28666 if (!SWIG_IsOK(res1)) {
28667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28668 }
28669 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28670 {
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 resultobj = SWIG_From_int(static_cast< int >(result));
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28684 PyObject *resultobj = 0;
28685 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28686 int result;
28687 void *argp1 = 0 ;
28688 int res1 = 0 ;
28689 PyObject *swig_obj[1] ;
28690
28691 if (!args) SWIG_fail;
28692 swig_obj[0] = args;
28693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28694 if (!SWIG_IsOK(res1)) {
28695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28696 }
28697 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28701 wxPyEndAllowThreads(__tstate);
28702 if (PyErr_Occurred()) SWIG_fail;
28703 }
28704 resultobj = SWIG_From_int(static_cast< int >(result));
28705 return resultobj;
28706 fail:
28707 return NULL;
28708 }
28709
28710
28711 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28712 PyObject *resultobj = 0;
28713 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28714 int result;
28715 void *argp1 = 0 ;
28716 int res1 = 0 ;
28717 PyObject *swig_obj[1] ;
28718
28719 if (!args) SWIG_fail;
28720 swig_obj[0] = args;
28721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28722 if (!SWIG_IsOK(res1)) {
28723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28724 }
28725 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 resultobj = SWIG_From_int(static_cast< int >(result));
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28740 PyObject *resultobj = 0;
28741 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28742 wxLongLong result;
28743 void *argp1 = 0 ;
28744 int res1 = 0 ;
28745 PyObject *swig_obj[1] ;
28746
28747 if (!args) SWIG_fail;
28748 swig_obj[0] = args;
28749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28750 if (!SWIG_IsOK(res1)) {
28751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28752 }
28753 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28754 {
28755 PyThreadState* __tstate = wxPyBeginAllowThreads();
28756 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28757 wxPyEndAllowThreads(__tstate);
28758 if (PyErr_Occurred()) SWIG_fail;
28759 }
28760 {
28761 PyObject *hi, *lo, *shifter, *shifted;
28762 hi = PyLong_FromLong( (&result)->GetHi() );
28763 lo = PyLong_FromLong( (&result)->GetLo() );
28764 shifter = PyLong_FromLong(32);
28765 shifted = PyNumber_Lshift(hi, shifter);
28766 resultobj = PyNumber_Or(shifted, lo);
28767 Py_DECREF(hi);
28768 Py_DECREF(lo);
28769 Py_DECREF(shifter);
28770 Py_DECREF(shifted);
28771 }
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28779 PyObject *resultobj = 0;
28780 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28781 wxLongLong result;
28782 void *argp1 = 0 ;
28783 int res1 = 0 ;
28784 PyObject *swig_obj[1] ;
28785
28786 if (!args) SWIG_fail;
28787 swig_obj[0] = args;
28788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28789 if (!SWIG_IsOK(res1)) {
28790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28791 }
28792 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 {
28800 PyObject *hi, *lo, *shifter, *shifted;
28801 hi = PyLong_FromLong( (&result)->GetHi() );
28802 lo = PyLong_FromLong( (&result)->GetLo() );
28803 shifter = PyLong_FromLong(32);
28804 shifted = PyNumber_Lshift(hi, shifter);
28805 resultobj = PyNumber_Or(shifted, lo);
28806 Py_DECREF(hi);
28807 Py_DECREF(lo);
28808 Py_DECREF(shifter);
28809 Py_DECREF(shifted);
28810 }
28811 return resultobj;
28812 fail:
28813 return NULL;
28814 }
28815
28816
28817 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28818 PyObject *resultobj = 0;
28819 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28820 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28821 wxString *arg2 = (wxString *) &arg2_defvalue ;
28822 wxString result;
28823 void *argp1 = 0 ;
28824 int res1 = 0 ;
28825 bool temp2 = false ;
28826 PyObject * obj0 = 0 ;
28827 PyObject * obj1 = 0 ;
28828 char * kwnames[] = {
28829 (char *) "self",(char *) "format", NULL
28830 };
28831
28832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28834 if (!SWIG_IsOK(res1)) {
28835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28836 }
28837 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28838 if (obj1) {
28839 {
28840 arg2 = wxString_in_helper(obj1);
28841 if (arg2 == NULL) SWIG_fail;
28842 temp2 = true;
28843 }
28844 }
28845 {
28846 PyThreadState* __tstate = wxPyBeginAllowThreads();
28847 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28848 wxPyEndAllowThreads(__tstate);
28849 if (PyErr_Occurred()) SWIG_fail;
28850 }
28851 {
28852 #if wxUSE_UNICODE
28853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28854 #else
28855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28856 #endif
28857 }
28858 {
28859 if (temp2)
28860 delete arg2;
28861 }
28862 return resultobj;
28863 fail:
28864 {
28865 if (temp2)
28866 delete arg2;
28867 }
28868 return NULL;
28869 }
28870
28871
28872 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28873 PyObject *obj;
28874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28875 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28876 return SWIG_Py_Void();
28877 }
28878
28879 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28880 return SWIG_Python_InitShadowInstance(args);
28881 }
28882
28883 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28884 PyObject *resultobj = 0;
28885 int arg1 = (int) 0 ;
28886 int arg2 = (int) 0 ;
28887 int arg3 = (int) 0 ;
28888 int arg4 = (int) 0 ;
28889 wxDateSpan *result = 0 ;
28890 int val1 ;
28891 int ecode1 = 0 ;
28892 int val2 ;
28893 int ecode2 = 0 ;
28894 int val3 ;
28895 int ecode3 = 0 ;
28896 int val4 ;
28897 int ecode4 = 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 PyObject * obj2 = 0 ;
28901 PyObject * obj3 = 0 ;
28902 char * kwnames[] = {
28903 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28904 };
28905
28906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28907 if (obj0) {
28908 ecode1 = SWIG_AsVal_int(obj0, &val1);
28909 if (!SWIG_IsOK(ecode1)) {
28910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28911 }
28912 arg1 = static_cast< int >(val1);
28913 }
28914 if (obj1) {
28915 ecode2 = SWIG_AsVal_int(obj1, &val2);
28916 if (!SWIG_IsOK(ecode2)) {
28917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28918 }
28919 arg2 = static_cast< int >(val2);
28920 }
28921 if (obj2) {
28922 ecode3 = SWIG_AsVal_int(obj2, &val3);
28923 if (!SWIG_IsOK(ecode3)) {
28924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28925 }
28926 arg3 = static_cast< int >(val3);
28927 }
28928 if (obj3) {
28929 ecode4 = SWIG_AsVal_int(obj3, &val4);
28930 if (!SWIG_IsOK(ecode4)) {
28931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28932 }
28933 arg4 = static_cast< int >(val4);
28934 }
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28942 return resultobj;
28943 fail:
28944 return NULL;
28945 }
28946
28947
28948 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28949 PyObject *resultobj = 0;
28950 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
28951 void *argp1 = 0 ;
28952 int res1 = 0 ;
28953 PyObject *swig_obj[1] ;
28954
28955 if (!args) SWIG_fail;
28956 swig_obj[0] = args;
28957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
28958 if (!SWIG_IsOK(res1)) {
28959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
28960 }
28961 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 delete arg1;
28965
28966 wxPyEndAllowThreads(__tstate);
28967 if (PyErr_Occurred()) SWIG_fail;
28968 }
28969 resultobj = SWIG_Py_Void();
28970 return resultobj;
28971 fail:
28972 return NULL;
28973 }
28974
28975
28976 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28977 PyObject *resultobj = 0;
28978 int arg1 ;
28979 wxDateSpan result;
28980 int val1 ;
28981 int ecode1 = 0 ;
28982 PyObject * obj0 = 0 ;
28983 char * kwnames[] = {
28984 (char *) "days", NULL
28985 };
28986
28987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
28988 ecode1 = SWIG_AsVal_int(obj0, &val1);
28989 if (!SWIG_IsOK(ecode1)) {
28990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
28991 }
28992 arg1 = static_cast< int >(val1);
28993 {
28994 PyThreadState* __tstate = wxPyBeginAllowThreads();
28995 result = wxDateSpan::Days(arg1);
28996 wxPyEndAllowThreads(__tstate);
28997 if (PyErr_Occurred()) SWIG_fail;
28998 }
28999 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29000 return resultobj;
29001 fail:
29002 return NULL;
29003 }
29004
29005
29006 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29007 PyObject *resultobj = 0;
29008 wxDateSpan result;
29009
29010 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29011 {
29012 PyThreadState* __tstate = wxPyBeginAllowThreads();
29013 result = wxDateSpan::Day();
29014 wxPyEndAllowThreads(__tstate);
29015 if (PyErr_Occurred()) SWIG_fail;
29016 }
29017 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29018 return resultobj;
29019 fail:
29020 return NULL;
29021 }
29022
29023
29024 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29025 PyObject *resultobj = 0;
29026 int arg1 ;
29027 wxDateSpan result;
29028 int val1 ;
29029 int ecode1 = 0 ;
29030 PyObject * obj0 = 0 ;
29031 char * kwnames[] = {
29032 (char *) "weeks", NULL
29033 };
29034
29035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29036 ecode1 = SWIG_AsVal_int(obj0, &val1);
29037 if (!SWIG_IsOK(ecode1)) {
29038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29039 }
29040 arg1 = static_cast< int >(val1);
29041 {
29042 PyThreadState* __tstate = wxPyBeginAllowThreads();
29043 result = wxDateSpan::Weeks(arg1);
29044 wxPyEndAllowThreads(__tstate);
29045 if (PyErr_Occurred()) SWIG_fail;
29046 }
29047 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29048 return resultobj;
29049 fail:
29050 return NULL;
29051 }
29052
29053
29054 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29055 PyObject *resultobj = 0;
29056 wxDateSpan result;
29057
29058 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29059 {
29060 PyThreadState* __tstate = wxPyBeginAllowThreads();
29061 result = wxDateSpan::Week();
29062 wxPyEndAllowThreads(__tstate);
29063 if (PyErr_Occurred()) SWIG_fail;
29064 }
29065 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29066 return resultobj;
29067 fail:
29068 return NULL;
29069 }
29070
29071
29072 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29073 PyObject *resultobj = 0;
29074 int arg1 ;
29075 wxDateSpan result;
29076 int val1 ;
29077 int ecode1 = 0 ;
29078 PyObject * obj0 = 0 ;
29079 char * kwnames[] = {
29080 (char *) "mon", NULL
29081 };
29082
29083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29084 ecode1 = SWIG_AsVal_int(obj0, &val1);
29085 if (!SWIG_IsOK(ecode1)) {
29086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29087 }
29088 arg1 = static_cast< int >(val1);
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 result = wxDateSpan::Months(arg1);
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29096 return resultobj;
29097 fail:
29098 return NULL;
29099 }
29100
29101
29102 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29103 PyObject *resultobj = 0;
29104 wxDateSpan result;
29105
29106 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 result = wxDateSpan::Month();
29110 wxPyEndAllowThreads(__tstate);
29111 if (PyErr_Occurred()) SWIG_fail;
29112 }
29113 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29114 return resultobj;
29115 fail:
29116 return NULL;
29117 }
29118
29119
29120 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29121 PyObject *resultobj = 0;
29122 int arg1 ;
29123 wxDateSpan result;
29124 int val1 ;
29125 int ecode1 = 0 ;
29126 PyObject * obj0 = 0 ;
29127 char * kwnames[] = {
29128 (char *) "years", NULL
29129 };
29130
29131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29132 ecode1 = SWIG_AsVal_int(obj0, &val1);
29133 if (!SWIG_IsOK(ecode1)) {
29134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29135 }
29136 arg1 = static_cast< int >(val1);
29137 {
29138 PyThreadState* __tstate = wxPyBeginAllowThreads();
29139 result = wxDateSpan::Years(arg1);
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29144 return resultobj;
29145 fail:
29146 return NULL;
29147 }
29148
29149
29150 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29151 PyObject *resultobj = 0;
29152 wxDateSpan result;
29153
29154 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29155 {
29156 PyThreadState* __tstate = wxPyBeginAllowThreads();
29157 result = wxDateSpan::Year();
29158 wxPyEndAllowThreads(__tstate);
29159 if (PyErr_Occurred()) SWIG_fail;
29160 }
29161 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29162 return resultobj;
29163 fail:
29164 return NULL;
29165 }
29166
29167
29168 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29169 PyObject *resultobj = 0;
29170 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29171 int arg2 ;
29172 wxDateSpan *result = 0 ;
29173 void *argp1 = 0 ;
29174 int res1 = 0 ;
29175 int val2 ;
29176 int ecode2 = 0 ;
29177 PyObject * obj0 = 0 ;
29178 PyObject * obj1 = 0 ;
29179 char * kwnames[] = {
29180 (char *) "self",(char *) "n", NULL
29181 };
29182
29183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29185 if (!SWIG_IsOK(res1)) {
29186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29187 }
29188 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29189 ecode2 = SWIG_AsVal_int(obj1, &val2);
29190 if (!SWIG_IsOK(ecode2)) {
29191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29192 }
29193 arg2 = static_cast< int >(val2);
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 {
29197 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29198 result = (wxDateSpan *) &_result_ref;
29199 }
29200 wxPyEndAllowThreads(__tstate);
29201 if (PyErr_Occurred()) SWIG_fail;
29202 }
29203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(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_SetMonths",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_SetMonths" "', 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_SetMonths" "', expected argument " "2"" of type '" "int""'");
29234 }
29235 arg2 = static_cast< int >(val2);
29236 {
29237 PyThreadState* __tstate = wxPyBeginAllowThreads();
29238 {
29239 wxDateSpan &_result_ref = (arg1)->SetMonths(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_SetWeeks(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_SetWeeks",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_SetWeeks" "', 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_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29276 }
29277 arg2 = static_cast< int >(val2);
29278 {
29279 PyThreadState* __tstate = wxPyBeginAllowThreads();
29280 {
29281 wxDateSpan &_result_ref = (arg1)->SetWeeks(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_SetDays(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_SetDays",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_SetDays" "', 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_SetDays" "', expected argument " "2"" of type '" "int""'");
29318 }
29319 arg2 = static_cast< int >(val2);
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 {
29323 wxDateSpan &_result_ref = (arg1)->SetDays(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_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29337 PyObject *resultobj = 0;
29338 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29339 int result;
29340 void *argp1 = 0 ;
29341 int res1 = 0 ;
29342 PyObject *swig_obj[1] ;
29343
29344 if (!args) SWIG_fail;
29345 swig_obj[0] = args;
29346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29347 if (!SWIG_IsOK(res1)) {
29348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29349 }
29350 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 result = (int)((wxDateSpan const *)arg1)->GetYears();
29354 wxPyEndAllowThreads(__tstate);
29355 if (PyErr_Occurred()) SWIG_fail;
29356 }
29357 resultobj = SWIG_From_int(static_cast< int >(result));
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29365 PyObject *resultobj = 0;
29366 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29367 int result;
29368 void *argp1 = 0 ;
29369 int res1 = 0 ;
29370 PyObject *swig_obj[1] ;
29371
29372 if (!args) SWIG_fail;
29373 swig_obj[0] = args;
29374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29375 if (!SWIG_IsOK(res1)) {
29376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29377 }
29378 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 resultobj = SWIG_From_int(static_cast< int >(result));
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29393 PyObject *resultobj = 0;
29394 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29395 int result;
29396 void *argp1 = 0 ;
29397 int res1 = 0 ;
29398 PyObject *swig_obj[1] ;
29399
29400 if (!args) SWIG_fail;
29401 swig_obj[0] = args;
29402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29403 if (!SWIG_IsOK(res1)) {
29404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29405 }
29406 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29407 {
29408 PyThreadState* __tstate = wxPyBeginAllowThreads();
29409 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29410 wxPyEndAllowThreads(__tstate);
29411 if (PyErr_Occurred()) SWIG_fail;
29412 }
29413 resultobj = SWIG_From_int(static_cast< int >(result));
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29421 PyObject *resultobj = 0;
29422 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29423 int result;
29424 void *argp1 = 0 ;
29425 int res1 = 0 ;
29426 PyObject *swig_obj[1] ;
29427
29428 if (!args) SWIG_fail;
29429 swig_obj[0] = args;
29430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29431 if (!SWIG_IsOK(res1)) {
29432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29433 }
29434 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29435 {
29436 PyThreadState* __tstate = wxPyBeginAllowThreads();
29437 result = (int)((wxDateSpan const *)arg1)->GetDays();
29438 wxPyEndAllowThreads(__tstate);
29439 if (PyErr_Occurred()) SWIG_fail;
29440 }
29441 resultobj = SWIG_From_int(static_cast< int >(result));
29442 return resultobj;
29443 fail:
29444 return NULL;
29445 }
29446
29447
29448 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29449 PyObject *resultobj = 0;
29450 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29451 int result;
29452 void *argp1 = 0 ;
29453 int res1 = 0 ;
29454 PyObject *swig_obj[1] ;
29455
29456 if (!args) SWIG_fail;
29457 swig_obj[0] = args;
29458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29459 if (!SWIG_IsOK(res1)) {
29460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29461 }
29462 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_From_int(static_cast< int >(result));
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = 0;
29478 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29479 wxDateSpan *arg2 = 0 ;
29480 wxDateSpan *result = 0 ;
29481 void *argp1 = 0 ;
29482 int res1 = 0 ;
29483 void *argp2 = 0 ;
29484 int res2 = 0 ;
29485 PyObject * obj0 = 0 ;
29486 PyObject * obj1 = 0 ;
29487 char * kwnames[] = {
29488 (char *) "self",(char *) "other", NULL
29489 };
29490
29491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29493 if (!SWIG_IsOK(res1)) {
29494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29495 }
29496 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29497 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29498 if (!SWIG_IsOK(res2)) {
29499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29500 }
29501 if (!argp2) {
29502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29503 }
29504 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29505 {
29506 PyThreadState* __tstate = wxPyBeginAllowThreads();
29507 {
29508 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29509 result = (wxDateSpan *) &_result_ref;
29510 }
29511 wxPyEndAllowThreads(__tstate);
29512 if (PyErr_Occurred()) SWIG_fail;
29513 }
29514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29515 return resultobj;
29516 fail:
29517 return NULL;
29518 }
29519
29520
29521 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29522 PyObject *resultobj = 0;
29523 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29524 wxDateSpan *arg2 = 0 ;
29525 wxDateSpan *result = 0 ;
29526 void *argp1 = 0 ;
29527 int res1 = 0 ;
29528 void *argp2 = 0 ;
29529 int res2 = 0 ;
29530 PyObject * obj0 = 0 ;
29531 PyObject * obj1 = 0 ;
29532 char * kwnames[] = {
29533 (char *) "self",(char *) "other", NULL
29534 };
29535
29536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29538 if (!SWIG_IsOK(res1)) {
29539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29540 }
29541 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29542 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29543 if (!SWIG_IsOK(res2)) {
29544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29545 }
29546 if (!argp2) {
29547 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29548 }
29549 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29550 {
29551 PyThreadState* __tstate = wxPyBeginAllowThreads();
29552 {
29553 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29554 result = (wxDateSpan *) &_result_ref;
29555 }
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29560 return resultobj;
29561 fail:
29562 return NULL;
29563 }
29564
29565
29566 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29567 PyObject *resultobj = 0;
29568 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29569 wxDateSpan *result = 0 ;
29570 void *argp1 = 0 ;
29571 int res1 = 0 ;
29572 PyObject *swig_obj[1] ;
29573
29574 if (!args) SWIG_fail;
29575 swig_obj[0] = args;
29576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29577 if (!SWIG_IsOK(res1)) {
29578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29579 }
29580 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29581 {
29582 PyThreadState* __tstate = wxPyBeginAllowThreads();
29583 {
29584 wxDateSpan &_result_ref = (arg1)->Neg();
29585 result = (wxDateSpan *) &_result_ref;
29586 }
29587 wxPyEndAllowThreads(__tstate);
29588 if (PyErr_Occurred()) SWIG_fail;
29589 }
29590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29591 return resultobj;
29592 fail:
29593 return NULL;
29594 }
29595
29596
29597 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29598 PyObject *resultobj = 0;
29599 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29600 int arg2 ;
29601 wxDateSpan *result = 0 ;
29602 void *argp1 = 0 ;
29603 int res1 = 0 ;
29604 int val2 ;
29605 int ecode2 = 0 ;
29606 PyObject * obj0 = 0 ;
29607 PyObject * obj1 = 0 ;
29608 char * kwnames[] = {
29609 (char *) "self",(char *) "factor", NULL
29610 };
29611
29612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29614 if (!SWIG_IsOK(res1)) {
29615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29616 }
29617 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29618 ecode2 = SWIG_AsVal_int(obj1, &val2);
29619 if (!SWIG_IsOK(ecode2)) {
29620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29621 }
29622 arg2 = static_cast< int >(val2);
29623 {
29624 PyThreadState* __tstate = wxPyBeginAllowThreads();
29625 {
29626 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
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___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29640 PyObject *resultobj = 0;
29641 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29642 wxDateSpan *arg2 = 0 ;
29643 wxDateSpan *result = 0 ;
29644 void *argp1 = 0 ;
29645 int res1 = 0 ;
29646 void *argp2 = 0 ;
29647 int res2 = 0 ;
29648 PyObject * obj0 = 0 ;
29649 PyObject * obj1 = 0 ;
29650 char * kwnames[] = {
29651 (char *) "self",(char *) "other", NULL
29652 };
29653
29654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29656 if (!SWIG_IsOK(res1)) {
29657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29658 }
29659 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29660 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29661 if (!SWIG_IsOK(res2)) {
29662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29663 }
29664 if (!argp2) {
29665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29666 }
29667 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29668 {
29669 PyThreadState* __tstate = wxPyBeginAllowThreads();
29670 {
29671 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29672 result = (wxDateSpan *) &_result_ref;
29673 }
29674 wxPyEndAllowThreads(__tstate);
29675 if (PyErr_Occurred()) SWIG_fail;
29676 }
29677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29678 return resultobj;
29679 fail:
29680 return NULL;
29681 }
29682
29683
29684 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29685 PyObject *resultobj = 0;
29686 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29687 wxDateSpan *arg2 = 0 ;
29688 wxDateSpan *result = 0 ;
29689 void *argp1 = 0 ;
29690 int res1 = 0 ;
29691 void *argp2 = 0 ;
29692 int res2 = 0 ;
29693 PyObject * obj0 = 0 ;
29694 PyObject * obj1 = 0 ;
29695 char * kwnames[] = {
29696 (char *) "self",(char *) "other", NULL
29697 };
29698
29699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29701 if (!SWIG_IsOK(res1)) {
29702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29703 }
29704 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29705 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29706 if (!SWIG_IsOK(res2)) {
29707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29708 }
29709 if (!argp2) {
29710 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29711 }
29712 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29713 {
29714 PyThreadState* __tstate = wxPyBeginAllowThreads();
29715 {
29716 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29717 result = (wxDateSpan *) &_result_ref;
29718 }
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29723 return resultobj;
29724 fail:
29725 return NULL;
29726 }
29727
29728
29729 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29730 PyObject *resultobj = 0;
29731 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29732 wxDateSpan *result = 0 ;
29733 void *argp1 = 0 ;
29734 int res1 = 0 ;
29735 PyObject *swig_obj[1] ;
29736
29737 if (!args) SWIG_fail;
29738 swig_obj[0] = args;
29739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29740 if (!SWIG_IsOK(res1)) {
29741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29742 }
29743 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29744 {
29745 PyThreadState* __tstate = wxPyBeginAllowThreads();
29746 {
29747 wxDateSpan &_result_ref = (arg1)->operator -();
29748 result = (wxDateSpan *) &_result_ref;
29749 }
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29754 return resultobj;
29755 fail:
29756 return NULL;
29757 }
29758
29759
29760 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29761 PyObject *resultobj = 0;
29762 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29763 int arg2 ;
29764 wxDateSpan *result = 0 ;
29765 void *argp1 = 0 ;
29766 int res1 = 0 ;
29767 int val2 ;
29768 int ecode2 = 0 ;
29769 PyObject * obj0 = 0 ;
29770 PyObject * obj1 = 0 ;
29771 char * kwnames[] = {
29772 (char *) "self",(char *) "factor", NULL
29773 };
29774
29775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29777 if (!SWIG_IsOK(res1)) {
29778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29779 }
29780 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29781 ecode2 = SWIG_AsVal_int(obj1, &val2);
29782 if (!SWIG_IsOK(ecode2)) {
29783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29784 }
29785 arg2 = static_cast< int >(val2);
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 {
29789 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
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, SWIG_POINTER_OWN | 0 );
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj = 0;
29804 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29805 wxDateSpan *arg2 = 0 ;
29806 wxDateSpan result;
29807 void *argp1 = 0 ;
29808 int res1 = 0 ;
29809 void *argp2 = 0 ;
29810 int res2 = 0 ;
29811 PyObject * obj0 = 0 ;
29812 PyObject * obj1 = 0 ;
29813 char * kwnames[] = {
29814 (char *) "self",(char *) "other", NULL
29815 };
29816
29817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29819 if (!SWIG_IsOK(res1)) {
29820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29821 }
29822 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29824 if (!SWIG_IsOK(res2)) {
29825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29826 }
29827 if (!argp2) {
29828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29829 }
29830 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29834 wxPyEndAllowThreads(__tstate);
29835 if (PyErr_Occurred()) SWIG_fail;
29836 }
29837 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29838 return resultobj;
29839 fail:
29840 return NULL;
29841 }
29842
29843
29844 SWIGINTERN PyObject *_wrap_DateSpan___sub__(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___sub__",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___sub__" "', 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___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29868 }
29869 if (!argp2) {
29870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29871 }
29872 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29873 {
29874 PyThreadState* __tstate = wxPyBeginAllowThreads();
29875 result = wxDateSpan___sub__(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___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29887 PyObject *resultobj = 0;
29888 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29889 int arg2 ;
29890 wxDateSpan result;
29891 void *argp1 = 0 ;
29892 int res1 = 0 ;
29893 int val2 ;
29894 int ecode2 = 0 ;
29895 PyObject * obj0 = 0 ;
29896 PyObject * obj1 = 0 ;
29897 char * kwnames[] = {
29898 (char *) "self",(char *) "n", NULL
29899 };
29900
29901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",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___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29905 }
29906 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29907 ecode2 = SWIG_AsVal_int(obj1, &val2);
29908 if (!SWIG_IsOK(ecode2)) {
29909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29910 }
29911 arg2 = static_cast< int >(val2);
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = wxDateSpan___mul__(arg1,arg2);
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj = 0;
29927 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29928 int arg2 ;
29929 wxDateSpan result;
29930 void *argp1 = 0 ;
29931 int res1 = 0 ;
29932 int val2 ;
29933 int ecode2 = 0 ;
29934 PyObject * obj0 = 0 ;
29935 PyObject * obj1 = 0 ;
29936 char * kwnames[] = {
29937 (char *) "self",(char *) "n", NULL
29938 };
29939
29940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29942 if (!SWIG_IsOK(res1)) {
29943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29944 }
29945 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29946 ecode2 = SWIG_AsVal_int(obj1, &val2);
29947 if (!SWIG_IsOK(ecode2)) {
29948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29949 }
29950 arg2 = static_cast< int >(val2);
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 result = wxDateSpan___rmul__(arg1,arg2);
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29958 return resultobj;
29959 fail:
29960 return NULL;
29961 }
29962
29963
29964 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29965 PyObject *resultobj = 0;
29966 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29967 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
29968 bool result;
29969 void *argp1 = 0 ;
29970 int res1 = 0 ;
29971 void *argp2 = 0 ;
29972 int res2 = 0 ;
29973 PyObject * obj0 = 0 ;
29974 PyObject * obj1 = 0 ;
29975 char * kwnames[] = {
29976 (char *) "self",(char *) "other", NULL
29977 };
29978
29979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29981 if (!SWIG_IsOK(res1)) {
29982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29983 }
29984 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29986 if (!SWIG_IsOK(res2)) {
29987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
29988 }
29989 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29990 {
29991 PyThreadState* __tstate = wxPyBeginAllowThreads();
29992 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
29993 wxPyEndAllowThreads(__tstate);
29994 if (PyErr_Occurred()) SWIG_fail;
29995 }
29996 {
29997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29998 }
29999 return resultobj;
30000 fail:
30001 return NULL;
30002 }
30003
30004
30005 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30006 PyObject *resultobj = 0;
30007 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30008 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30009 bool result;
30010 void *argp1 = 0 ;
30011 int res1 = 0 ;
30012 void *argp2 = 0 ;
30013 int res2 = 0 ;
30014 PyObject * obj0 = 0 ;
30015 PyObject * obj1 = 0 ;
30016 char * kwnames[] = {
30017 (char *) "self",(char *) "other", NULL
30018 };
30019
30020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30022 if (!SWIG_IsOK(res1)) {
30023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30024 }
30025 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30027 if (!SWIG_IsOK(res2)) {
30028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30029 }
30030 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30031 {
30032 PyThreadState* __tstate = wxPyBeginAllowThreads();
30033 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30034 wxPyEndAllowThreads(__tstate);
30035 if (PyErr_Occurred()) SWIG_fail;
30036 }
30037 {
30038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30039 }
30040 return resultobj;
30041 fail:
30042 return NULL;
30043 }
30044
30045
30046 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30047 PyObject *obj;
30048 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30049 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30050 return SWIG_Py_Void();
30051 }
30052
30053 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30054 return SWIG_Python_InitShadowInstance(args);
30055 }
30056
30057 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30058 PyObject *resultobj = 0;
30059 long result;
30060
30061 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 result = (long)wxGetLocalTime();
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 resultobj = SWIG_From_long(static_cast< long >(result));
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30076 PyObject *resultobj = 0;
30077 long result;
30078
30079 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30080 {
30081 PyThreadState* __tstate = wxPyBeginAllowThreads();
30082 result = (long)wxGetUTCTime();
30083 wxPyEndAllowThreads(__tstate);
30084 if (PyErr_Occurred()) SWIG_fail;
30085 }
30086 resultobj = SWIG_From_long(static_cast< long >(result));
30087 return resultobj;
30088 fail:
30089 return NULL;
30090 }
30091
30092
30093 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30094 PyObject *resultobj = 0;
30095 long result;
30096
30097 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = (long)wxGetCurrentTime();
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 resultobj = SWIG_From_long(static_cast< long >(result));
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30112 PyObject *resultobj = 0;
30113 wxLongLong result;
30114
30115 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30116 {
30117 PyThreadState* __tstate = wxPyBeginAllowThreads();
30118 result = wxGetLocalTimeMillis();
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 {
30123 PyObject *hi, *lo, *shifter, *shifted;
30124 hi = PyLong_FromLong( (&result)->GetHi() );
30125 lo = PyLong_FromLong( (&result)->GetLo() );
30126 shifter = PyLong_FromLong(32);
30127 shifted = PyNumber_Lshift(hi, shifter);
30128 resultobj = PyNumber_Or(shifted, lo);
30129 Py_DECREF(hi);
30130 Py_DECREF(lo);
30131 Py_DECREF(shifter);
30132 Py_DECREF(shifted);
30133 }
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30141 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30142 return 1;
30143 }
30144
30145
30146 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30147 PyObject *pyobj = 0;
30148
30149 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30150 return pyobj;
30151 }
30152
30153
30154 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30155 PyObject *resultobj = 0;
30156 wxDataFormatId arg1 ;
30157 wxDataFormat *result = 0 ;
30158 int val1 ;
30159 int ecode1 = 0 ;
30160 PyObject * obj0 = 0 ;
30161 char * kwnames[] = {
30162 (char *) "type", NULL
30163 };
30164
30165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30166 ecode1 = SWIG_AsVal_int(obj0, &val1);
30167 if (!SWIG_IsOK(ecode1)) {
30168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30169 }
30170 arg1 = static_cast< wxDataFormatId >(val1);
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 result = (wxDataFormat *)new wxDataFormat(arg1);
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30185 PyObject *resultobj = 0;
30186 wxString *arg1 = 0 ;
30187 wxDataFormat *result = 0 ;
30188 bool temp1 = false ;
30189 PyObject * obj0 = 0 ;
30190 char * kwnames[] = {
30191 (char *) "format", NULL
30192 };
30193
30194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30195 {
30196 arg1 = wxString_in_helper(obj0);
30197 if (arg1 == NULL) SWIG_fail;
30198 temp1 = true;
30199 }
30200 {
30201 PyThreadState* __tstate = wxPyBeginAllowThreads();
30202 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30203 wxPyEndAllowThreads(__tstate);
30204 if (PyErr_Occurred()) SWIG_fail;
30205 }
30206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30207 {
30208 if (temp1)
30209 delete arg1;
30210 }
30211 return resultobj;
30212 fail:
30213 {
30214 if (temp1)
30215 delete arg1;
30216 }
30217 return NULL;
30218 }
30219
30220
30221 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30222 PyObject *resultobj = 0;
30223 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30224 void *argp1 = 0 ;
30225 int res1 = 0 ;
30226 PyObject *swig_obj[1] ;
30227
30228 if (!args) SWIG_fail;
30229 swig_obj[0] = args;
30230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30231 if (!SWIG_IsOK(res1)) {
30232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30233 }
30234 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30235 {
30236 PyThreadState* __tstate = wxPyBeginAllowThreads();
30237 delete arg1;
30238
30239 wxPyEndAllowThreads(__tstate);
30240 if (PyErr_Occurred()) SWIG_fail;
30241 }
30242 resultobj = SWIG_Py_Void();
30243 return resultobj;
30244 fail:
30245 return NULL;
30246 }
30247
30248
30249 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30250 PyObject *resultobj = 0;
30251 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30252 wxDataFormatId arg2 ;
30253 bool result;
30254 void *argp1 = 0 ;
30255 int res1 = 0 ;
30256 int val2 ;
30257 int ecode2 = 0 ;
30258
30259 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30261 if (!SWIG_IsOK(res1)) {
30262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30263 }
30264 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30265 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30266 if (!SWIG_IsOK(ecode2)) {
30267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30268 }
30269 arg2 = static_cast< wxDataFormatId >(val2);
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30273 wxPyEndAllowThreads(__tstate);
30274 if (PyErr_Occurred()) SWIG_fail;
30275 }
30276 {
30277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30278 }
30279 return resultobj;
30280 fail:
30281 return NULL;
30282 }
30283
30284
30285 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30286 PyObject *resultobj = 0;
30287 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30288 wxDataFormatId arg2 ;
30289 bool result;
30290 void *argp1 = 0 ;
30291 int res1 = 0 ;
30292 int val2 ;
30293 int ecode2 = 0 ;
30294
30295 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30297 if (!SWIG_IsOK(res1)) {
30298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30299 }
30300 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30301 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30302 if (!SWIG_IsOK(ecode2)) {
30303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30304 }
30305 arg2 = static_cast< wxDataFormatId >(val2);
30306 {
30307 PyThreadState* __tstate = wxPyBeginAllowThreads();
30308 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30309 wxPyEndAllowThreads(__tstate);
30310 if (PyErr_Occurred()) SWIG_fail;
30311 }
30312 {
30313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30314 }
30315 return resultobj;
30316 fail:
30317 return NULL;
30318 }
30319
30320
30321 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30322 PyObject *resultobj = 0;
30323 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30324 wxDataFormat *arg2 = 0 ;
30325 bool result;
30326 void *argp1 = 0 ;
30327 int res1 = 0 ;
30328 void *argp2 = 0 ;
30329 int res2 = 0 ;
30330
30331 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30333 if (!SWIG_IsOK(res1)) {
30334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30335 }
30336 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30337 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30338 if (!SWIG_IsOK(res2)) {
30339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30340 }
30341 if (!argp2) {
30342 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30343 }
30344 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30345 {
30346 PyThreadState* __tstate = wxPyBeginAllowThreads();
30347 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30348 wxPyEndAllowThreads(__tstate);
30349 if (PyErr_Occurred()) SWIG_fail;
30350 }
30351 {
30352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30353 }
30354 return resultobj;
30355 fail:
30356 return NULL;
30357 }
30358
30359
30360 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30361 int argc;
30362 PyObject *argv[3];
30363
30364 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30365 --argc;
30366 if (argc == 2) {
30367 int _v = 0;
30368 {
30369 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30370 _v = SWIG_CheckState(res);
30371 }
30372 if (!_v) goto check_1;
30373 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30374 }
30375 check_1:
30376
30377 if (argc == 2) {
30378 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30379 }
30380
30381 fail:
30382 Py_INCREF(Py_NotImplemented);
30383 return Py_NotImplemented;
30384 }
30385
30386
30387 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30388 PyObject *resultobj = 0;
30389 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30390 wxDataFormat *arg2 = 0 ;
30391 bool result;
30392 void *argp1 = 0 ;
30393 int res1 = 0 ;
30394 void *argp2 = 0 ;
30395 int res2 = 0 ;
30396
30397 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30399 if (!SWIG_IsOK(res1)) {
30400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30401 }
30402 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30403 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30404 if (!SWIG_IsOK(res2)) {
30405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30406 }
30407 if (!argp2) {
30408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30409 }
30410 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 {
30418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30419 }
30420 return resultobj;
30421 fail:
30422 return NULL;
30423 }
30424
30425
30426 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30427 int argc;
30428 PyObject *argv[3];
30429
30430 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30431 --argc;
30432 if (argc == 2) {
30433 int _v = 0;
30434 {
30435 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30436 _v = SWIG_CheckState(res);
30437 }
30438 if (!_v) goto check_1;
30439 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30440 }
30441 check_1:
30442
30443 if (argc == 2) {
30444 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30445 }
30446
30447 fail:
30448 Py_INCREF(Py_NotImplemented);
30449 return Py_NotImplemented;
30450 }
30451
30452
30453 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30454 PyObject *resultobj = 0;
30455 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30456 wxDataFormatId arg2 ;
30457 void *argp1 = 0 ;
30458 int res1 = 0 ;
30459 int val2 ;
30460 int ecode2 = 0 ;
30461 PyObject * obj0 = 0 ;
30462 PyObject * obj1 = 0 ;
30463 char * kwnames[] = {
30464 (char *) "self",(char *) "format", NULL
30465 };
30466
30467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30469 if (!SWIG_IsOK(res1)) {
30470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30471 }
30472 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30473 ecode2 = SWIG_AsVal_int(obj1, &val2);
30474 if (!SWIG_IsOK(ecode2)) {
30475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30476 }
30477 arg2 = static_cast< wxDataFormatId >(val2);
30478 {
30479 PyThreadState* __tstate = wxPyBeginAllowThreads();
30480 (arg1)->SetType(arg2);
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 resultobj = SWIG_Py_Void();
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30492 PyObject *resultobj = 0;
30493 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30494 wxDataFormatId result;
30495 void *argp1 = 0 ;
30496 int res1 = 0 ;
30497 PyObject *swig_obj[1] ;
30498
30499 if (!args) SWIG_fail;
30500 swig_obj[0] = args;
30501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30502 if (!SWIG_IsOK(res1)) {
30503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30504 }
30505 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30506 {
30507 PyThreadState* __tstate = wxPyBeginAllowThreads();
30508 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 resultobj = SWIG_From_int(static_cast< int >(result));
30513 return resultobj;
30514 fail:
30515 return NULL;
30516 }
30517
30518
30519 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30520 PyObject *resultobj = 0;
30521 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30522 wxString result;
30523 void *argp1 = 0 ;
30524 int res1 = 0 ;
30525 PyObject *swig_obj[1] ;
30526
30527 if (!args) SWIG_fail;
30528 swig_obj[0] = args;
30529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30530 if (!SWIG_IsOK(res1)) {
30531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30532 }
30533 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 result = ((wxDataFormat const *)arg1)->GetId();
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 {
30541 #if wxUSE_UNICODE
30542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30543 #else
30544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30545 #endif
30546 }
30547 return resultobj;
30548 fail:
30549 return NULL;
30550 }
30551
30552
30553 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30554 PyObject *resultobj = 0;
30555 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30556 wxString *arg2 = 0 ;
30557 void *argp1 = 0 ;
30558 int res1 = 0 ;
30559 bool temp2 = false ;
30560 PyObject * obj0 = 0 ;
30561 PyObject * obj1 = 0 ;
30562 char * kwnames[] = {
30563 (char *) "self",(char *) "format", NULL
30564 };
30565
30566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30568 if (!SWIG_IsOK(res1)) {
30569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30570 }
30571 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30572 {
30573 arg2 = wxString_in_helper(obj1);
30574 if (arg2 == NULL) SWIG_fail;
30575 temp2 = true;
30576 }
30577 {
30578 PyThreadState* __tstate = wxPyBeginAllowThreads();
30579 (arg1)->SetId((wxString const &)*arg2);
30580 wxPyEndAllowThreads(__tstate);
30581 if (PyErr_Occurred()) SWIG_fail;
30582 }
30583 resultobj = SWIG_Py_Void();
30584 {
30585 if (temp2)
30586 delete arg2;
30587 }
30588 return resultobj;
30589 fail:
30590 {
30591 if (temp2)
30592 delete arg2;
30593 }
30594 return NULL;
30595 }
30596
30597
30598 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30599 PyObject *obj;
30600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30601 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30602 return SWIG_Py_Void();
30603 }
30604
30605 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30606 return SWIG_Python_InitShadowInstance(args);
30607 }
30608
30609 SWIGINTERN int FormatInvalid_set(PyObject *) {
30610 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30611 return 1;
30612 }
30613
30614
30615 SWIGINTERN PyObject *FormatInvalid_get(void) {
30616 PyObject *pyobj = 0;
30617
30618 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30619 return pyobj;
30620 }
30621
30622
30623 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30624 PyObject *resultobj = 0;
30625 wxDataObject *arg1 = (wxDataObject *) 0 ;
30626 void *argp1 = 0 ;
30627 int res1 = 0 ;
30628 PyObject *swig_obj[1] ;
30629
30630 if (!args) SWIG_fail;
30631 swig_obj[0] = args;
30632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30633 if (!SWIG_IsOK(res1)) {
30634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30635 }
30636 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 delete arg1;
30640
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 resultobj = SWIG_Py_Void();
30645 return resultobj;
30646 fail:
30647 return NULL;
30648 }
30649
30650
30651 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30652 PyObject *resultobj = 0;
30653 wxDataObject *arg1 = (wxDataObject *) 0 ;
30654 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30655 SwigValueWrapper<wxDataFormat > result;
30656 void *argp1 = 0 ;
30657 int res1 = 0 ;
30658 int val2 ;
30659 int ecode2 = 0 ;
30660 PyObject * obj0 = 0 ;
30661 PyObject * obj1 = 0 ;
30662 char * kwnames[] = {
30663 (char *) "self",(char *) "dir", NULL
30664 };
30665
30666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30668 if (!SWIG_IsOK(res1)) {
30669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30670 }
30671 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30672 if (obj1) {
30673 ecode2 = SWIG_AsVal_int(obj1, &val2);
30674 if (!SWIG_IsOK(ecode2)) {
30675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30676 }
30677 arg2 = static_cast< wxDataObject::Direction >(val2);
30678 }
30679 {
30680 PyThreadState* __tstate = wxPyBeginAllowThreads();
30681 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30682 wxPyEndAllowThreads(__tstate);
30683 if (PyErr_Occurred()) SWIG_fail;
30684 }
30685 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj = 0;
30694 wxDataObject *arg1 = (wxDataObject *) 0 ;
30695 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30696 size_t result;
30697 void *argp1 = 0 ;
30698 int res1 = 0 ;
30699 int val2 ;
30700 int ecode2 = 0 ;
30701 PyObject * obj0 = 0 ;
30702 PyObject * obj1 = 0 ;
30703 char * kwnames[] = {
30704 (char *) "self",(char *) "dir", NULL
30705 };
30706
30707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30709 if (!SWIG_IsOK(res1)) {
30710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30711 }
30712 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30713 if (obj1) {
30714 ecode2 = SWIG_AsVal_int(obj1, &val2);
30715 if (!SWIG_IsOK(ecode2)) {
30716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30717 }
30718 arg2 = static_cast< wxDataObject::Direction >(val2);
30719 }
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj = 0;
30735 wxDataObject *arg1 = (wxDataObject *) 0 ;
30736 wxDataFormat *arg2 = 0 ;
30737 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30738 bool result;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 void *argp2 = 0 ;
30742 int res2 = 0 ;
30743 int val3 ;
30744 int ecode3 = 0 ;
30745 PyObject * obj0 = 0 ;
30746 PyObject * obj1 = 0 ;
30747 PyObject * obj2 = 0 ;
30748 char * kwnames[] = {
30749 (char *) "self",(char *) "format",(char *) "dir", NULL
30750 };
30751
30752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30754 if (!SWIG_IsOK(res1)) {
30755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30756 }
30757 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30758 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30759 if (!SWIG_IsOK(res2)) {
30760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30761 }
30762 if (!argp2) {
30763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30764 }
30765 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30766 if (obj2) {
30767 ecode3 = SWIG_AsVal_int(obj2, &val3);
30768 if (!SWIG_IsOK(ecode3)) {
30769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30770 }
30771 arg3 = static_cast< wxDataObject::Direction >(val3);
30772 }
30773 {
30774 PyThreadState* __tstate = wxPyBeginAllowThreads();
30775 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30776 wxPyEndAllowThreads(__tstate);
30777 if (PyErr_Occurred()) SWIG_fail;
30778 }
30779 {
30780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30781 }
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj = 0;
30790 wxDataObject *arg1 = (wxDataObject *) 0 ;
30791 wxDataFormat *arg2 = 0 ;
30792 size_t result;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 void *argp2 = 0 ;
30796 int res2 = 0 ;
30797 PyObject * obj0 = 0 ;
30798 PyObject * obj1 = 0 ;
30799 char * kwnames[] = {
30800 (char *) "self",(char *) "format", NULL
30801 };
30802
30803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30805 if (!SWIG_IsOK(res1)) {
30806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30807 }
30808 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30810 if (!SWIG_IsOK(res2)) {
30811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30812 }
30813 if (!argp2) {
30814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30815 }
30816 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj = 0;
30832 wxDataObject *arg1 = (wxDataObject *) 0 ;
30833 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30834 PyObject *result = 0 ;
30835 void *argp1 = 0 ;
30836 int res1 = 0 ;
30837 int val2 ;
30838 int ecode2 = 0 ;
30839 PyObject * obj0 = 0 ;
30840 PyObject * obj1 = 0 ;
30841 char * kwnames[] = {
30842 (char *) "self",(char *) "dir", NULL
30843 };
30844
30845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",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_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30849 }
30850 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30851 if (obj1) {
30852 ecode2 = SWIG_AsVal_int(obj1, &val2);
30853 if (!SWIG_IsOK(ecode2)) {
30854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30855 }
30856 arg2 = static_cast< wxDataObject::Direction >(val2);
30857 }
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30861 wxPyEndAllowThreads(__tstate);
30862 if (PyErr_Occurred()) SWIG_fail;
30863 }
30864 resultobj = result;
30865 return resultobj;
30866 fail:
30867 return NULL;
30868 }
30869
30870
30871 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30872 PyObject *resultobj = 0;
30873 wxDataObject *arg1 = (wxDataObject *) 0 ;
30874 wxDataFormat *arg2 = 0 ;
30875 PyObject *result = 0 ;
30876 void *argp1 = 0 ;
30877 int res1 = 0 ;
30878 void *argp2 = 0 ;
30879 int res2 = 0 ;
30880 PyObject * obj0 = 0 ;
30881 PyObject * obj1 = 0 ;
30882 char * kwnames[] = {
30883 (char *) "self",(char *) "format", NULL
30884 };
30885
30886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30888 if (!SWIG_IsOK(res1)) {
30889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30890 }
30891 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30892 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30893 if (!SWIG_IsOK(res2)) {
30894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30895 }
30896 if (!argp2) {
30897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30898 }
30899 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30900 {
30901 PyThreadState* __tstate = wxPyBeginAllowThreads();
30902 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*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_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30914 PyObject *resultobj = 0;
30915 wxDataObject *arg1 = (wxDataObject *) 0 ;
30916 wxDataFormat *arg2 = 0 ;
30917 PyObject *arg3 = (PyObject *) 0 ;
30918 bool result;
30919 void *argp1 = 0 ;
30920 int res1 = 0 ;
30921 void *argp2 = 0 ;
30922 int res2 = 0 ;
30923 PyObject * obj0 = 0 ;
30924 PyObject * obj1 = 0 ;
30925 PyObject * obj2 = 0 ;
30926 char * kwnames[] = {
30927 (char *) "self",(char *) "format",(char *) "data", NULL
30928 };
30929
30930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30932 if (!SWIG_IsOK(res1)) {
30933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30934 }
30935 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30936 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30937 if (!SWIG_IsOK(res2)) {
30938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30939 }
30940 if (!argp2) {
30941 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30942 }
30943 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30944 arg3 = obj2;
30945 {
30946 PyThreadState* __tstate = wxPyBeginAllowThreads();
30947 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
30948 wxPyEndAllowThreads(__tstate);
30949 if (PyErr_Occurred()) SWIG_fail;
30950 }
30951 {
30952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30953 }
30954 return resultobj;
30955 fail:
30956 return NULL;
30957 }
30958
30959
30960 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30961 PyObject *obj;
30962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30963 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
30964 return SWIG_Py_Void();
30965 }
30966
30967 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30968 PyObject *resultobj = 0;
30969 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
30970 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
30971 wxDataObjectSimple *result = 0 ;
30972 void *argp1 = 0 ;
30973 int res1 = 0 ;
30974 PyObject * obj0 = 0 ;
30975 char * kwnames[] = {
30976 (char *) "format", NULL
30977 };
30978
30979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
30980 if (obj0) {
30981 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
30982 if (!SWIG_IsOK(res1)) {
30983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
30984 }
30985 if (!argp1) {
30986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
30987 }
30988 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30989 }
30990 {
30991 PyThreadState* __tstate = wxPyBeginAllowThreads();
30992 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
30993 wxPyEndAllowThreads(__tstate);
30994 if (PyErr_Occurred()) SWIG_fail;
30995 }
30996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
30997 return resultobj;
30998 fail:
30999 return NULL;
31000 }
31001
31002
31003 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31004 PyObject *resultobj = 0;
31005 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31006 wxDataFormat *result = 0 ;
31007 void *argp1 = 0 ;
31008 int res1 = 0 ;
31009 PyObject *swig_obj[1] ;
31010
31011 if (!args) SWIG_fail;
31012 swig_obj[0] = args;
31013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31014 if (!SWIG_IsOK(res1)) {
31015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31016 }
31017 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31018 {
31019 PyThreadState* __tstate = wxPyBeginAllowThreads();
31020 {
31021 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31022 result = (wxDataFormat *) &_result_ref;
31023 }
31024 wxPyEndAllowThreads(__tstate);
31025 if (PyErr_Occurred()) SWIG_fail;
31026 }
31027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31028 return resultobj;
31029 fail:
31030 return NULL;
31031 }
31032
31033
31034 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31035 PyObject *resultobj = 0;
31036 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31037 wxDataFormat *arg2 = 0 ;
31038 void *argp1 = 0 ;
31039 int res1 = 0 ;
31040 void *argp2 = 0 ;
31041 int res2 = 0 ;
31042 PyObject * obj0 = 0 ;
31043 PyObject * obj1 = 0 ;
31044 char * kwnames[] = {
31045 (char *) "self",(char *) "format", NULL
31046 };
31047
31048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31050 if (!SWIG_IsOK(res1)) {
31051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31052 }
31053 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31054 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31055 if (!SWIG_IsOK(res2)) {
31056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31057 }
31058 if (!argp2) {
31059 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31060 }
31061 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31062 {
31063 PyThreadState* __tstate = wxPyBeginAllowThreads();
31064 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 resultobj = SWIG_Py_Void();
31069 return resultobj;
31070 fail:
31071 return NULL;
31072 }
31073
31074
31075 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31076 PyObject *resultobj = 0;
31077 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31078 size_t result;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 PyObject *swig_obj[1] ;
31082
31083 if (!args) SWIG_fail;
31084 swig_obj[0] = args;
31085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31086 if (!SWIG_IsOK(res1)) {
31087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31088 }
31089 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31104 PyObject *resultobj = 0;
31105 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31106 PyObject *result = 0 ;
31107 void *argp1 = 0 ;
31108 int res1 = 0 ;
31109 PyObject *swig_obj[1] ;
31110
31111 if (!args) SWIG_fail;
31112 swig_obj[0] = args;
31113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31116 }
31117 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 resultobj = result;
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31132 PyObject *resultobj = 0;
31133 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31134 PyObject *arg2 = (PyObject *) 0 ;
31135 bool result;
31136 void *argp1 = 0 ;
31137 int res1 = 0 ;
31138 PyObject * obj0 = 0 ;
31139 PyObject * obj1 = 0 ;
31140 char * kwnames[] = {
31141 (char *) "self",(char *) "data", NULL
31142 };
31143
31144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31146 if (!SWIG_IsOK(res1)) {
31147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31148 }
31149 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31150 arg2 = obj1;
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 {
31158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31159 }
31160 return resultobj;
31161 fail:
31162 return NULL;
31163 }
31164
31165
31166 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31167 PyObject *obj;
31168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31169 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31170 return SWIG_Py_Void();
31171 }
31172
31173 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31174 return SWIG_Python_InitShadowInstance(args);
31175 }
31176
31177 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31178 PyObject *resultobj = 0;
31179 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31180 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31181 wxPyDataObjectSimple *result = 0 ;
31182 void *argp1 = 0 ;
31183 int res1 = 0 ;
31184 PyObject * obj0 = 0 ;
31185 char * kwnames[] = {
31186 (char *) "format", NULL
31187 };
31188
31189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31190 if (obj0) {
31191 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31192 if (!SWIG_IsOK(res1)) {
31193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31194 }
31195 if (!argp1) {
31196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31197 }
31198 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31199 }
31200 {
31201 PyThreadState* __tstate = wxPyBeginAllowThreads();
31202 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj = 0;
31215 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31216 PyObject *arg2 = (PyObject *) 0 ;
31217 PyObject *arg3 = (PyObject *) 0 ;
31218 void *argp1 = 0 ;
31219 int res1 = 0 ;
31220 PyObject * obj0 = 0 ;
31221 PyObject * obj1 = 0 ;
31222 PyObject * obj2 = 0 ;
31223 char * kwnames[] = {
31224 (char *) "self",(char *) "self",(char *) "_class", NULL
31225 };
31226
31227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31229 if (!SWIG_IsOK(res1)) {
31230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31231 }
31232 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31233 arg2 = obj1;
31234 arg3 = obj2;
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 (arg1)->_setCallbackInfo(arg2,arg3);
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_Py_Void();
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31249 PyObject *obj;
31250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31251 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31252 return SWIG_Py_Void();
31253 }
31254
31255 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31256 return SWIG_Python_InitShadowInstance(args);
31257 }
31258
31259 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31260 PyObject *resultobj = 0;
31261 wxDataObjectComposite *result = 0 ;
31262
31263 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj = 0;
31279 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31280 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31281 bool arg3 = (bool) false ;
31282 void *argp1 = 0 ;
31283 int res1 = 0 ;
31284 int res2 = 0 ;
31285 bool val3 ;
31286 int ecode3 = 0 ;
31287 PyObject * obj0 = 0 ;
31288 PyObject * obj1 = 0 ;
31289 PyObject * obj2 = 0 ;
31290 char * kwnames[] = {
31291 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31292 };
31293
31294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31296 if (!SWIG_IsOK(res1)) {
31297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31298 }
31299 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31300 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31301 if (!SWIG_IsOK(res2)) {
31302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31303 }
31304 if (obj2) {
31305 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31306 if (!SWIG_IsOK(ecode3)) {
31307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31308 }
31309 arg3 = static_cast< bool >(val3);
31310 }
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 (arg1)->Add(arg2,arg3);
31314 wxPyEndAllowThreads(__tstate);
31315 if (PyErr_Occurred()) SWIG_fail;
31316 }
31317 resultobj = SWIG_Py_Void();
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31325 PyObject *obj;
31326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31327 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31328 return SWIG_Py_Void();
31329 }
31330
31331 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31332 return SWIG_Python_InitShadowInstance(args);
31333 }
31334
31335 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31336 PyObject *resultobj = 0;
31337 wxString const &arg1_defvalue = wxPyEmptyString ;
31338 wxString *arg1 = (wxString *) &arg1_defvalue ;
31339 wxTextDataObject *result = 0 ;
31340 bool temp1 = false ;
31341 PyObject * obj0 = 0 ;
31342 char * kwnames[] = {
31343 (char *) "text", NULL
31344 };
31345
31346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31347 if (obj0) {
31348 {
31349 arg1 = wxString_in_helper(obj0);
31350 if (arg1 == NULL) SWIG_fail;
31351 temp1 = true;
31352 }
31353 }
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31361 {
31362 if (temp1)
31363 delete arg1;
31364 }
31365 return resultobj;
31366 fail:
31367 {
31368 if (temp1)
31369 delete arg1;
31370 }
31371 return NULL;
31372 }
31373
31374
31375 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31376 PyObject *resultobj = 0;
31377 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31378 size_t result;
31379 void *argp1 = 0 ;
31380 int res1 = 0 ;
31381 PyObject *swig_obj[1] ;
31382
31383 if (!args) SWIG_fail;
31384 swig_obj[0] = args;
31385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31386 if (!SWIG_IsOK(res1)) {
31387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31388 }
31389 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 result = (size_t)(arg1)->GetTextLength();
31393 wxPyEndAllowThreads(__tstate);
31394 if (PyErr_Occurred()) SWIG_fail;
31395 }
31396 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31397 return resultobj;
31398 fail:
31399 return NULL;
31400 }
31401
31402
31403 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31404 PyObject *resultobj = 0;
31405 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31406 wxString result;
31407 void *argp1 = 0 ;
31408 int res1 = 0 ;
31409 PyObject *swig_obj[1] ;
31410
31411 if (!args) SWIG_fail;
31412 swig_obj[0] = args;
31413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31414 if (!SWIG_IsOK(res1)) {
31415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31416 }
31417 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 result = (arg1)->GetText();
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 {
31425 #if wxUSE_UNICODE
31426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31427 #else
31428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31429 #endif
31430 }
31431 return resultobj;
31432 fail:
31433 return NULL;
31434 }
31435
31436
31437 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31438 PyObject *resultobj = 0;
31439 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31440 wxString *arg2 = 0 ;
31441 void *argp1 = 0 ;
31442 int res1 = 0 ;
31443 bool temp2 = false ;
31444 PyObject * obj0 = 0 ;
31445 PyObject * obj1 = 0 ;
31446 char * kwnames[] = {
31447 (char *) "self",(char *) "text", NULL
31448 };
31449
31450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31452 if (!SWIG_IsOK(res1)) {
31453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31454 }
31455 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31456 {
31457 arg2 = wxString_in_helper(obj1);
31458 if (arg2 == NULL) SWIG_fail;
31459 temp2 = true;
31460 }
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 (arg1)->SetText((wxString const &)*arg2);
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 resultobj = SWIG_Py_Void();
31468 {
31469 if (temp2)
31470 delete arg2;
31471 }
31472 return resultobj;
31473 fail:
31474 {
31475 if (temp2)
31476 delete arg2;
31477 }
31478 return NULL;
31479 }
31480
31481
31482 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31483 PyObject *obj;
31484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31485 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31486 return SWIG_Py_Void();
31487 }
31488
31489 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31490 return SWIG_Python_InitShadowInstance(args);
31491 }
31492
31493 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31494 PyObject *resultobj = 0;
31495 wxString const &arg1_defvalue = wxPyEmptyString ;
31496 wxString *arg1 = (wxString *) &arg1_defvalue ;
31497 wxPyTextDataObject *result = 0 ;
31498 bool temp1 = false ;
31499 PyObject * obj0 = 0 ;
31500 char * kwnames[] = {
31501 (char *) "text", NULL
31502 };
31503
31504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31505 if (obj0) {
31506 {
31507 arg1 = wxString_in_helper(obj0);
31508 if (arg1 == NULL) SWIG_fail;
31509 temp1 = true;
31510 }
31511 }
31512 {
31513 PyThreadState* __tstate = wxPyBeginAllowThreads();
31514 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31515 wxPyEndAllowThreads(__tstate);
31516 if (PyErr_Occurred()) SWIG_fail;
31517 }
31518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31519 {
31520 if (temp1)
31521 delete arg1;
31522 }
31523 return resultobj;
31524 fail:
31525 {
31526 if (temp1)
31527 delete arg1;
31528 }
31529 return NULL;
31530 }
31531
31532
31533 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31534 PyObject *resultobj = 0;
31535 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31536 PyObject *arg2 = (PyObject *) 0 ;
31537 PyObject *arg3 = (PyObject *) 0 ;
31538 void *argp1 = 0 ;
31539 int res1 = 0 ;
31540 PyObject * obj0 = 0 ;
31541 PyObject * obj1 = 0 ;
31542 PyObject * obj2 = 0 ;
31543 char * kwnames[] = {
31544 (char *) "self",(char *) "self",(char *) "_class", NULL
31545 };
31546
31547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31549 if (!SWIG_IsOK(res1)) {
31550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31551 }
31552 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31553 arg2 = obj1;
31554 arg3 = obj2;
31555 {
31556 PyThreadState* __tstate = wxPyBeginAllowThreads();
31557 (arg1)->_setCallbackInfo(arg2,arg3);
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 resultobj = SWIG_Py_Void();
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31569 PyObject *obj;
31570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31571 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31572 return SWIG_Py_Void();
31573 }
31574
31575 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31576 return SWIG_Python_InitShadowInstance(args);
31577 }
31578
31579 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31580 PyObject *resultobj = 0;
31581 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31582 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31583 wxBitmapDataObject *result = 0 ;
31584 void *argp1 = 0 ;
31585 int res1 = 0 ;
31586 PyObject * obj0 = 0 ;
31587 char * kwnames[] = {
31588 (char *) "bitmap", NULL
31589 };
31590
31591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31592 if (obj0) {
31593 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31594 if (!SWIG_IsOK(res1)) {
31595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31596 }
31597 if (!argp1) {
31598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31599 }
31600 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31601 }
31602 {
31603 PyThreadState* __tstate = wxPyBeginAllowThreads();
31604 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31605 wxPyEndAllowThreads(__tstate);
31606 if (PyErr_Occurred()) SWIG_fail;
31607 }
31608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31609 return resultobj;
31610 fail:
31611 return NULL;
31612 }
31613
31614
31615 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31616 PyObject *resultobj = 0;
31617 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31618 wxBitmap result;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 PyObject *swig_obj[1] ;
31622
31623 if (!args) SWIG_fail;
31624 swig_obj[0] = args;
31625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31626 if (!SWIG_IsOK(res1)) {
31627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31628 }
31629 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31637 return resultobj;
31638 fail:
31639 return NULL;
31640 }
31641
31642
31643 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31644 PyObject *resultobj = 0;
31645 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31646 wxBitmap *arg2 = 0 ;
31647 void *argp1 = 0 ;
31648 int res1 = 0 ;
31649 void *argp2 = 0 ;
31650 int res2 = 0 ;
31651 PyObject * obj0 = 0 ;
31652 PyObject * obj1 = 0 ;
31653 char * kwnames[] = {
31654 (char *) "self",(char *) "bitmap", NULL
31655 };
31656
31657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31659 if (!SWIG_IsOK(res1)) {
31660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31661 }
31662 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31663 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31664 if (!SWIG_IsOK(res2)) {
31665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31666 }
31667 if (!argp2) {
31668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31669 }
31670 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31671 {
31672 PyThreadState* __tstate = wxPyBeginAllowThreads();
31673 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 resultobj = SWIG_Py_Void();
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31685 PyObject *obj;
31686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31687 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31688 return SWIG_Py_Void();
31689 }
31690
31691 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31692 return SWIG_Python_InitShadowInstance(args);
31693 }
31694
31695 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31696 PyObject *resultobj = 0;
31697 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31698 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31699 wxPyBitmapDataObject *result = 0 ;
31700 void *argp1 = 0 ;
31701 int res1 = 0 ;
31702 PyObject * obj0 = 0 ;
31703 char * kwnames[] = {
31704 (char *) "bitmap", NULL
31705 };
31706
31707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31708 if (obj0) {
31709 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31710 if (!SWIG_IsOK(res1)) {
31711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31712 }
31713 if (!argp1) {
31714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31715 }
31716 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31717 }
31718 {
31719 PyThreadState* __tstate = wxPyBeginAllowThreads();
31720 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31721 wxPyEndAllowThreads(__tstate);
31722 if (PyErr_Occurred()) SWIG_fail;
31723 }
31724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31725 return resultobj;
31726 fail:
31727 return NULL;
31728 }
31729
31730
31731 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31732 PyObject *resultobj = 0;
31733 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31734 PyObject *arg2 = (PyObject *) 0 ;
31735 PyObject *arg3 = (PyObject *) 0 ;
31736 void *argp1 = 0 ;
31737 int res1 = 0 ;
31738 PyObject * obj0 = 0 ;
31739 PyObject * obj1 = 0 ;
31740 PyObject * obj2 = 0 ;
31741 char * kwnames[] = {
31742 (char *) "self",(char *) "self",(char *) "_class", NULL
31743 };
31744
31745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31747 if (!SWIG_IsOK(res1)) {
31748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31749 }
31750 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31751 arg2 = obj1;
31752 arg3 = obj2;
31753 {
31754 PyThreadState* __tstate = wxPyBeginAllowThreads();
31755 (arg1)->_setCallbackInfo(arg2,arg3);
31756 wxPyEndAllowThreads(__tstate);
31757 if (PyErr_Occurred()) SWIG_fail;
31758 }
31759 resultobj = SWIG_Py_Void();
31760 return resultobj;
31761 fail:
31762 return NULL;
31763 }
31764
31765
31766 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31767 PyObject *obj;
31768 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31769 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31770 return SWIG_Py_Void();
31771 }
31772
31773 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31774 return SWIG_Python_InitShadowInstance(args);
31775 }
31776
31777 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31778 PyObject *resultobj = 0;
31779 wxFileDataObject *result = 0 ;
31780
31781 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31782 {
31783 PyThreadState* __tstate = wxPyBeginAllowThreads();
31784 result = (wxFileDataObject *)new wxFileDataObject();
31785 wxPyEndAllowThreads(__tstate);
31786 if (PyErr_Occurred()) SWIG_fail;
31787 }
31788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31789 return resultobj;
31790 fail:
31791 return NULL;
31792 }
31793
31794
31795 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31796 PyObject *resultobj = 0;
31797 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31798 wxArrayString *result = 0 ;
31799 void *argp1 = 0 ;
31800 int res1 = 0 ;
31801 PyObject *swig_obj[1] ;
31802
31803 if (!args) SWIG_fail;
31804 swig_obj[0] = args;
31805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31808 }
31809 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 {
31813 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31814 result = (wxArrayString *) &_result_ref;
31815 }
31816 wxPyEndAllowThreads(__tstate);
31817 if (PyErr_Occurred()) SWIG_fail;
31818 }
31819 {
31820 resultobj = wxArrayString2PyList_helper(*result);
31821 }
31822 return resultobj;
31823 fail:
31824 return NULL;
31825 }
31826
31827
31828 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31829 PyObject *resultobj = 0;
31830 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31831 wxString *arg2 = 0 ;
31832 void *argp1 = 0 ;
31833 int res1 = 0 ;
31834 bool temp2 = false ;
31835 PyObject * obj0 = 0 ;
31836 PyObject * obj1 = 0 ;
31837 char * kwnames[] = {
31838 (char *) "self",(char *) "filename", NULL
31839 };
31840
31841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31843 if (!SWIG_IsOK(res1)) {
31844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31845 }
31846 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31847 {
31848 arg2 = wxString_in_helper(obj1);
31849 if (arg2 == NULL) SWIG_fail;
31850 temp2 = true;
31851 }
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 (arg1)->AddFile((wxString const &)*arg2);
31855 wxPyEndAllowThreads(__tstate);
31856 if (PyErr_Occurred()) SWIG_fail;
31857 }
31858 resultobj = SWIG_Py_Void();
31859 {
31860 if (temp2)
31861 delete arg2;
31862 }
31863 return resultobj;
31864 fail:
31865 {
31866 if (temp2)
31867 delete arg2;
31868 }
31869 return NULL;
31870 }
31871
31872
31873 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31874 PyObject *obj;
31875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31876 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31877 return SWIG_Py_Void();
31878 }
31879
31880 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881 return SWIG_Python_InitShadowInstance(args);
31882 }
31883
31884 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31885 PyObject *resultobj = 0;
31886 wxDataFormat *arg1 = 0 ;
31887 wxCustomDataObject *result = 0 ;
31888 void *argp1 = 0 ;
31889 int res1 = 0 ;
31890
31891 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31893 if (!SWIG_IsOK(res1)) {
31894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31895 }
31896 if (!argp1) {
31897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31898 }
31899 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31900 {
31901 PyThreadState* __tstate = wxPyBeginAllowThreads();
31902 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31903 wxPyEndAllowThreads(__tstate);
31904 if (PyErr_Occurred()) SWIG_fail;
31905 }
31906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31907 return resultobj;
31908 fail:
31909 return NULL;
31910 }
31911
31912
31913 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31914 PyObject *resultobj = 0;
31915 wxString *arg1 = 0 ;
31916 wxCustomDataObject *result = 0 ;
31917 bool temp1 = false ;
31918
31919 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31920 {
31921 arg1 = wxString_in_helper(swig_obj[0]);
31922 if (arg1 == NULL) SWIG_fail;
31923 temp1 = true;
31924 }
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31932 {
31933 if (temp1)
31934 delete arg1;
31935 }
31936 return resultobj;
31937 fail:
31938 {
31939 if (temp1)
31940 delete arg1;
31941 }
31942 return NULL;
31943 }
31944
31945
31946 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
31947 PyObject *resultobj = 0;
31948 wxCustomDataObject *result = 0 ;
31949
31950 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
31951 {
31952 PyThreadState* __tstate = wxPyBeginAllowThreads();
31953 result = (wxCustomDataObject *)new wxCustomDataObject();
31954 wxPyEndAllowThreads(__tstate);
31955 if (PyErr_Occurred()) SWIG_fail;
31956 }
31957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31958 return resultobj;
31959 fail:
31960 return NULL;
31961 }
31962
31963
31964 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
31965 int argc;
31966 PyObject *argv[2];
31967
31968 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
31969 --argc;
31970 if (argc == 0) {
31971 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
31972 }
31973 if (argc == 1) {
31974 int _v = 0;
31975 {
31976 {
31977 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
31978 }
31979 }
31980 if (!_v) goto check_2;
31981 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
31982 }
31983 check_2:
31984
31985 if (argc == 1) {
31986 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
31987 }
31988
31989 fail:
31990 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
31991 return NULL;
31992 }
31993
31994
31995 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31996 PyObject *resultobj = 0;
31997 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
31998 PyObject *arg2 = (PyObject *) 0 ;
31999 bool result;
32000 void *argp1 = 0 ;
32001 int res1 = 0 ;
32002 PyObject * obj0 = 0 ;
32003 PyObject * obj1 = 0 ;
32004 char * kwnames[] = {
32005 (char *) "self",(char *) "data", NULL
32006 };
32007
32008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32010 if (!SWIG_IsOK(res1)) {
32011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32012 }
32013 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32014 arg2 = obj1;
32015 {
32016 PyThreadState* __tstate = wxPyBeginAllowThreads();
32017 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32018 wxPyEndAllowThreads(__tstate);
32019 if (PyErr_Occurred()) SWIG_fail;
32020 }
32021 {
32022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32023 }
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32031 PyObject *resultobj = 0;
32032 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32033 size_t result;
32034 void *argp1 = 0 ;
32035 int res1 = 0 ;
32036 PyObject *swig_obj[1] ;
32037
32038 if (!args) SWIG_fail;
32039 swig_obj[0] = args;
32040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32041 if (!SWIG_IsOK(res1)) {
32042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32043 }
32044 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32045 {
32046 PyThreadState* __tstate = wxPyBeginAllowThreads();
32047 result = (size_t)(arg1)->GetSize();
32048 wxPyEndAllowThreads(__tstate);
32049 if (PyErr_Occurred()) SWIG_fail;
32050 }
32051 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32052 return resultobj;
32053 fail:
32054 return NULL;
32055 }
32056
32057
32058 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32059 PyObject *resultobj = 0;
32060 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32061 PyObject *result = 0 ;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 PyObject *swig_obj[1] ;
32065
32066 if (!args) SWIG_fail;
32067 swig_obj[0] = args;
32068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32069 if (!SWIG_IsOK(res1)) {
32070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32071 }
32072 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 resultobj = result;
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32087 PyObject *obj;
32088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32089 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32090 return SWIG_Py_Void();
32091 }
32092
32093 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32094 return SWIG_Python_InitShadowInstance(args);
32095 }
32096
32097 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32098 PyObject *resultobj = 0;
32099 wxURLDataObject *result = 0 ;
32100
32101 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32102 {
32103 PyThreadState* __tstate = wxPyBeginAllowThreads();
32104 result = (wxURLDataObject *)new wxURLDataObject();
32105 wxPyEndAllowThreads(__tstate);
32106 if (PyErr_Occurred()) SWIG_fail;
32107 }
32108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32109 return resultobj;
32110 fail:
32111 return NULL;
32112 }
32113
32114
32115 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32116 PyObject *resultobj = 0;
32117 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32118 wxString result;
32119 void *argp1 = 0 ;
32120 int res1 = 0 ;
32121 PyObject *swig_obj[1] ;
32122
32123 if (!args) SWIG_fail;
32124 swig_obj[0] = args;
32125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32126 if (!SWIG_IsOK(res1)) {
32127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32128 }
32129 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32130 {
32131 PyThreadState* __tstate = wxPyBeginAllowThreads();
32132 result = (arg1)->GetURL();
32133 wxPyEndAllowThreads(__tstate);
32134 if (PyErr_Occurred()) SWIG_fail;
32135 }
32136 {
32137 #if wxUSE_UNICODE
32138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32139 #else
32140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32141 #endif
32142 }
32143 return resultobj;
32144 fail:
32145 return NULL;
32146 }
32147
32148
32149 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32150 PyObject *resultobj = 0;
32151 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32152 wxString *arg2 = 0 ;
32153 void *argp1 = 0 ;
32154 int res1 = 0 ;
32155 bool temp2 = false ;
32156 PyObject * obj0 = 0 ;
32157 PyObject * obj1 = 0 ;
32158 char * kwnames[] = {
32159 (char *) "self",(char *) "url", NULL
32160 };
32161
32162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32164 if (!SWIG_IsOK(res1)) {
32165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32166 }
32167 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32168 {
32169 arg2 = wxString_in_helper(obj1);
32170 if (arg2 == NULL) SWIG_fail;
32171 temp2 = true;
32172 }
32173 {
32174 PyThreadState* __tstate = wxPyBeginAllowThreads();
32175 (arg1)->SetURL((wxString const &)*arg2);
32176 wxPyEndAllowThreads(__tstate);
32177 if (PyErr_Occurred()) SWIG_fail;
32178 }
32179 resultobj = SWIG_Py_Void();
32180 {
32181 if (temp2)
32182 delete arg2;
32183 }
32184 return resultobj;
32185 fail:
32186 {
32187 if (temp2)
32188 delete arg2;
32189 }
32190 return NULL;
32191 }
32192
32193
32194 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32195 PyObject *obj;
32196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32197 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32198 return SWIG_Py_Void();
32199 }
32200
32201 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32202 return SWIG_Python_InitShadowInstance(args);
32203 }
32204
32205 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32206 PyObject *resultobj = 0;
32207 wxMetafileDataObject *result = 0 ;
32208
32209 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32210 {
32211 PyThreadState* __tstate = wxPyBeginAllowThreads();
32212 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32217 return resultobj;
32218 fail:
32219 return NULL;
32220 }
32221
32222
32223 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32224 PyObject *obj;
32225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32226 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32227 return SWIG_Py_Void();
32228 }
32229
32230 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32231 return SWIG_Python_InitShadowInstance(args);
32232 }
32233
32234 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxDragResult arg1 ;
32237 bool result;
32238 int val1 ;
32239 int ecode1 = 0 ;
32240 PyObject * obj0 = 0 ;
32241 char * kwnames[] = {
32242 (char *) "res", NULL
32243 };
32244
32245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32246 ecode1 = SWIG_AsVal_int(obj0, &val1);
32247 if (!SWIG_IsOK(ecode1)) {
32248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32249 }
32250 arg1 = static_cast< wxDragResult >(val1);
32251 {
32252 PyThreadState* __tstate = wxPyBeginAllowThreads();
32253 result = (bool)wxIsDragResultOk(arg1);
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 {
32258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32259 }
32260 return resultobj;
32261 fail:
32262 return NULL;
32263 }
32264
32265
32266 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32267 PyObject *resultobj = 0;
32268 wxWindow *arg1 = (wxWindow *) 0 ;
32269 wxIcon const &arg2_defvalue = wxNullIcon ;
32270 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32271 wxIcon const &arg3_defvalue = wxNullIcon ;
32272 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32273 wxIcon const &arg4_defvalue = wxNullIcon ;
32274 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32275 wxPyDropSource *result = 0 ;
32276 void *argp1 = 0 ;
32277 int res1 = 0 ;
32278 void *argp2 = 0 ;
32279 int res2 = 0 ;
32280 void *argp3 = 0 ;
32281 int res3 = 0 ;
32282 void *argp4 = 0 ;
32283 int res4 = 0 ;
32284 PyObject * obj0 = 0 ;
32285 PyObject * obj1 = 0 ;
32286 PyObject * obj2 = 0 ;
32287 PyObject * obj3 = 0 ;
32288 char * kwnames[] = {
32289 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32290 };
32291
32292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32294 if (!SWIG_IsOK(res1)) {
32295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32296 }
32297 arg1 = reinterpret_cast< wxWindow * >(argp1);
32298 if (obj1) {
32299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32300 if (!SWIG_IsOK(res2)) {
32301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32302 }
32303 if (!argp2) {
32304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32305 }
32306 arg2 = reinterpret_cast< wxIcon * >(argp2);
32307 }
32308 if (obj2) {
32309 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32310 if (!SWIG_IsOK(res3)) {
32311 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32312 }
32313 if (!argp3) {
32314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32315 }
32316 arg3 = reinterpret_cast< wxIcon * >(argp3);
32317 }
32318 if (obj3) {
32319 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32320 if (!SWIG_IsOK(res4)) {
32321 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32322 }
32323 if (!argp4) {
32324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32325 }
32326 arg4 = reinterpret_cast< wxIcon * >(argp4);
32327 }
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32331 wxPyEndAllowThreads(__tstate);
32332 if (PyErr_Occurred()) SWIG_fail;
32333 }
32334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj = 0;
32343 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32344 PyObject *arg2 = (PyObject *) 0 ;
32345 PyObject *arg3 = (PyObject *) 0 ;
32346 int arg4 ;
32347 void *argp1 = 0 ;
32348 int res1 = 0 ;
32349 int val4 ;
32350 int ecode4 = 0 ;
32351 PyObject * obj0 = 0 ;
32352 PyObject * obj1 = 0 ;
32353 PyObject * obj2 = 0 ;
32354 PyObject * obj3 = 0 ;
32355 char * kwnames[] = {
32356 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32357 };
32358
32359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32361 if (!SWIG_IsOK(res1)) {
32362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32363 }
32364 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32365 arg2 = obj1;
32366 arg3 = obj2;
32367 ecode4 = SWIG_AsVal_int(obj3, &val4);
32368 if (!SWIG_IsOK(ecode4)) {
32369 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32370 }
32371 arg4 = static_cast< int >(val4);
32372 {
32373 PyThreadState* __tstate = wxPyBeginAllowThreads();
32374 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32375 wxPyEndAllowThreads(__tstate);
32376 if (PyErr_Occurred()) SWIG_fail;
32377 }
32378 resultobj = SWIG_Py_Void();
32379 return resultobj;
32380 fail:
32381 return NULL;
32382 }
32383
32384
32385 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32386 PyObject *resultobj = 0;
32387 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32388 void *argp1 = 0 ;
32389 int res1 = 0 ;
32390 PyObject *swig_obj[1] ;
32391
32392 if (!args) SWIG_fail;
32393 swig_obj[0] = args;
32394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32395 if (!SWIG_IsOK(res1)) {
32396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32397 }
32398 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32399 {
32400 PyThreadState* __tstate = wxPyBeginAllowThreads();
32401 delete arg1;
32402
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 resultobj = SWIG_Py_Void();
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj = 0;
32415 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32416 wxDataObject *arg2 = 0 ;
32417 void *argp1 = 0 ;
32418 int res1 = 0 ;
32419 void *argp2 = 0 ;
32420 int res2 = 0 ;
32421 PyObject * obj0 = 0 ;
32422 PyObject * obj1 = 0 ;
32423 char * kwnames[] = {
32424 (char *) "self",(char *) "data", NULL
32425 };
32426
32427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32429 if (!SWIG_IsOK(res1)) {
32430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32431 }
32432 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32433 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32434 if (!SWIG_IsOK(res2)) {
32435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32436 }
32437 if (!argp2) {
32438 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32439 }
32440 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32441 {
32442 PyThreadState* __tstate = wxPyBeginAllowThreads();
32443 (arg1)->SetData(*arg2);
32444 wxPyEndAllowThreads(__tstate);
32445 if (PyErr_Occurred()) SWIG_fail;
32446 }
32447 resultobj = SWIG_Py_Void();
32448 return resultobj;
32449 fail:
32450 return NULL;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32455 PyObject *resultobj = 0;
32456 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32457 wxDataObject *result = 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, 0 | 0 );
32465 if (!SWIG_IsOK(res1)) {
32466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32467 }
32468 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 result = (wxDataObject *)(arg1)->GetDataObject();
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32476 return resultobj;
32477 fail:
32478 return NULL;
32479 }
32480
32481
32482 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32483 PyObject *resultobj = 0;
32484 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32485 wxDragResult arg2 ;
32486 wxCursor *arg3 = 0 ;
32487 void *argp1 = 0 ;
32488 int res1 = 0 ;
32489 int val2 ;
32490 int ecode2 = 0 ;
32491 void *argp3 = 0 ;
32492 int res3 = 0 ;
32493 PyObject * obj0 = 0 ;
32494 PyObject * obj1 = 0 ;
32495 PyObject * obj2 = 0 ;
32496 char * kwnames[] = {
32497 (char *) "self",(char *) "res",(char *) "cursor", NULL
32498 };
32499
32500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32502 if (!SWIG_IsOK(res1)) {
32503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32504 }
32505 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32506 ecode2 = SWIG_AsVal_int(obj1, &val2);
32507 if (!SWIG_IsOK(ecode2)) {
32508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32509 }
32510 arg2 = static_cast< wxDragResult >(val2);
32511 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32512 if (!SWIG_IsOK(res3)) {
32513 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32514 }
32515 if (!argp3) {
32516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32517 }
32518 arg3 = reinterpret_cast< wxCursor * >(argp3);
32519 {
32520 PyThreadState* __tstate = wxPyBeginAllowThreads();
32521 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32522 wxPyEndAllowThreads(__tstate);
32523 if (PyErr_Occurred()) SWIG_fail;
32524 }
32525 resultobj = SWIG_Py_Void();
32526 return resultobj;
32527 fail:
32528 return NULL;
32529 }
32530
32531
32532 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32533 PyObject *resultobj = 0;
32534 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32535 int arg2 = (int) wxDrag_CopyOnly ;
32536 wxDragResult result;
32537 void *argp1 = 0 ;
32538 int res1 = 0 ;
32539 int val2 ;
32540 int ecode2 = 0 ;
32541 PyObject * obj0 = 0 ;
32542 PyObject * obj1 = 0 ;
32543 char * kwnames[] = {
32544 (char *) "self",(char *) "flags", NULL
32545 };
32546
32547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32549 if (!SWIG_IsOK(res1)) {
32550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32551 }
32552 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32553 if (obj1) {
32554 ecode2 = SWIG_AsVal_int(obj1, &val2);
32555 if (!SWIG_IsOK(ecode2)) {
32556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32557 }
32558 arg2 = static_cast< int >(val2);
32559 }
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 resultobj = SWIG_From_int(static_cast< int >(result));
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32574 PyObject *resultobj = 0;
32575 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32576 wxDragResult arg2 ;
32577 bool result;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 int val2 ;
32581 int ecode2 = 0 ;
32582 PyObject * obj0 = 0 ;
32583 PyObject * obj1 = 0 ;
32584 char * kwnames[] = {
32585 (char *) "self",(char *) "effect", NULL
32586 };
32587
32588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32590 if (!SWIG_IsOK(res1)) {
32591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32592 }
32593 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32594 ecode2 = SWIG_AsVal_int(obj1, &val2);
32595 if (!SWIG_IsOK(ecode2)) {
32596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32597 }
32598 arg2 = static_cast< wxDragResult >(val2);
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 result = (bool)(arg1)->GiveFeedback(arg2);
32602 wxPyEndAllowThreads(__tstate);
32603 if (PyErr_Occurred()) SWIG_fail;
32604 }
32605 {
32606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32607 }
32608 return resultobj;
32609 fail:
32610 return NULL;
32611 }
32612
32613
32614 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32615 PyObject *obj;
32616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32617 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32618 return SWIG_Py_Void();
32619 }
32620
32621 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32622 return SWIG_Python_InitShadowInstance(args);
32623 }
32624
32625 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32626 PyObject *resultobj = 0;
32627 wxDataObject *arg1 = (wxDataObject *) NULL ;
32628 wxPyDropTarget *result = 0 ;
32629 int res1 = 0 ;
32630 PyObject * obj0 = 0 ;
32631 char * kwnames[] = {
32632 (char *) "dataObject", NULL
32633 };
32634
32635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32636 if (obj0) {
32637 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32638 if (!SWIG_IsOK(res1)) {
32639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32640 }
32641 }
32642 {
32643 PyThreadState* __tstate = wxPyBeginAllowThreads();
32644 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32645 wxPyEndAllowThreads(__tstate);
32646 if (PyErr_Occurred()) SWIG_fail;
32647 }
32648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32649 return resultobj;
32650 fail:
32651 return NULL;
32652 }
32653
32654
32655 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32656 PyObject *resultobj = 0;
32657 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32658 PyObject *arg2 = (PyObject *) 0 ;
32659 PyObject *arg3 = (PyObject *) 0 ;
32660 void *argp1 = 0 ;
32661 int res1 = 0 ;
32662 PyObject * obj0 = 0 ;
32663 PyObject * obj1 = 0 ;
32664 PyObject * obj2 = 0 ;
32665 char * kwnames[] = {
32666 (char *) "self",(char *) "self",(char *) "_class", NULL
32667 };
32668
32669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32671 if (!SWIG_IsOK(res1)) {
32672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32673 }
32674 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32675 arg2 = obj1;
32676 arg3 = obj2;
32677 {
32678 PyThreadState* __tstate = wxPyBeginAllowThreads();
32679 (arg1)->_setCallbackInfo(arg2,arg3);
32680 wxPyEndAllowThreads(__tstate);
32681 if (PyErr_Occurred()) SWIG_fail;
32682 }
32683 resultobj = SWIG_Py_Void();
32684 return resultobj;
32685 fail:
32686 return NULL;
32687 }
32688
32689
32690 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32691 PyObject *resultobj = 0;
32692 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32693 void *argp1 = 0 ;
32694 int res1 = 0 ;
32695 PyObject *swig_obj[1] ;
32696
32697 if (!args) SWIG_fail;
32698 swig_obj[0] = args;
32699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32700 if (!SWIG_IsOK(res1)) {
32701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32702 }
32703 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32704 {
32705 PyThreadState* __tstate = wxPyBeginAllowThreads();
32706 delete arg1;
32707
32708 wxPyEndAllowThreads(__tstate);
32709 if (PyErr_Occurred()) SWIG_fail;
32710 }
32711 resultobj = SWIG_Py_Void();
32712 return resultobj;
32713 fail:
32714 return NULL;
32715 }
32716
32717
32718 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32719 PyObject *resultobj = 0;
32720 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32721 wxDataObject *result = 0 ;
32722 void *argp1 = 0 ;
32723 int res1 = 0 ;
32724 PyObject *swig_obj[1] ;
32725
32726 if (!args) SWIG_fail;
32727 swig_obj[0] = args;
32728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32729 if (!SWIG_IsOK(res1)) {
32730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32731 }
32732 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32733 {
32734 PyThreadState* __tstate = wxPyBeginAllowThreads();
32735 result = (wxDataObject *)(arg1)->GetDataObject();
32736 wxPyEndAllowThreads(__tstate);
32737 if (PyErr_Occurred()) SWIG_fail;
32738 }
32739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32740 return resultobj;
32741 fail:
32742 return NULL;
32743 }
32744
32745
32746 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32747 PyObject *resultobj = 0;
32748 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32749 wxDataObject *arg2 = (wxDataObject *) 0 ;
32750 void *argp1 = 0 ;
32751 int res1 = 0 ;
32752 int res2 = 0 ;
32753 PyObject * obj0 = 0 ;
32754 PyObject * obj1 = 0 ;
32755 char * kwnames[] = {
32756 (char *) "self",(char *) "dataObject", NULL
32757 };
32758
32759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32763 }
32764 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32765 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32766 if (!SWIG_IsOK(res2)) {
32767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32768 }
32769 {
32770 PyThreadState* __tstate = wxPyBeginAllowThreads();
32771 (arg1)->SetDataObject(arg2);
32772 wxPyEndAllowThreads(__tstate);
32773 if (PyErr_Occurred()) SWIG_fail;
32774 }
32775 resultobj = SWIG_Py_Void();
32776 return resultobj;
32777 fail:
32778 return NULL;
32779 }
32780
32781
32782 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32783 PyObject *resultobj = 0;
32784 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32785 int arg2 ;
32786 int arg3 ;
32787 wxDragResult arg4 ;
32788 wxDragResult result;
32789 void *argp1 = 0 ;
32790 int res1 = 0 ;
32791 int val2 ;
32792 int ecode2 = 0 ;
32793 int val3 ;
32794 int ecode3 = 0 ;
32795 int val4 ;
32796 int ecode4 = 0 ;
32797 PyObject * obj0 = 0 ;
32798 PyObject * obj1 = 0 ;
32799 PyObject * obj2 = 0 ;
32800 PyObject * obj3 = 0 ;
32801 char * kwnames[] = {
32802 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32803 };
32804
32805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32807 if (!SWIG_IsOK(res1)) {
32808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32809 }
32810 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32811 ecode2 = SWIG_AsVal_int(obj1, &val2);
32812 if (!SWIG_IsOK(ecode2)) {
32813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32814 }
32815 arg2 = static_cast< int >(val2);
32816 ecode3 = SWIG_AsVal_int(obj2, &val3);
32817 if (!SWIG_IsOK(ecode3)) {
32818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32819 }
32820 arg3 = static_cast< int >(val3);
32821 ecode4 = SWIG_AsVal_int(obj3, &val4);
32822 if (!SWIG_IsOK(ecode4)) {
32823 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32824 }
32825 arg4 = static_cast< wxDragResult >(val4);
32826 {
32827 PyThreadState* __tstate = wxPyBeginAllowThreads();
32828 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32829 wxPyEndAllowThreads(__tstate);
32830 if (PyErr_Occurred()) SWIG_fail;
32831 }
32832 resultobj = SWIG_From_int(static_cast< int >(result));
32833 return resultobj;
32834 fail:
32835 return NULL;
32836 }
32837
32838
32839 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32840 PyObject *resultobj = 0;
32841 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32842 int arg2 ;
32843 int arg3 ;
32844 wxDragResult arg4 ;
32845 wxDragResult result;
32846 void *argp1 = 0 ;
32847 int res1 = 0 ;
32848 int val2 ;
32849 int ecode2 = 0 ;
32850 int val3 ;
32851 int ecode3 = 0 ;
32852 int val4 ;
32853 int ecode4 = 0 ;
32854 PyObject * obj0 = 0 ;
32855 PyObject * obj1 = 0 ;
32856 PyObject * obj2 = 0 ;
32857 PyObject * obj3 = 0 ;
32858 char * kwnames[] = {
32859 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32860 };
32861
32862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32864 if (!SWIG_IsOK(res1)) {
32865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32866 }
32867 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32868 ecode2 = SWIG_AsVal_int(obj1, &val2);
32869 if (!SWIG_IsOK(ecode2)) {
32870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32871 }
32872 arg2 = static_cast< int >(val2);
32873 ecode3 = SWIG_AsVal_int(obj2, &val3);
32874 if (!SWIG_IsOK(ecode3)) {
32875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32876 }
32877 arg3 = static_cast< int >(val3);
32878 ecode4 = SWIG_AsVal_int(obj3, &val4);
32879 if (!SWIG_IsOK(ecode4)) {
32880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32881 }
32882 arg4 = static_cast< wxDragResult >(val4);
32883 {
32884 PyThreadState* __tstate = wxPyBeginAllowThreads();
32885 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32886 wxPyEndAllowThreads(__tstate);
32887 if (PyErr_Occurred()) SWIG_fail;
32888 }
32889 resultobj = SWIG_From_int(static_cast< int >(result));
32890 return resultobj;
32891 fail:
32892 return NULL;
32893 }
32894
32895
32896 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32897 PyObject *resultobj = 0;
32898 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32899 void *argp1 = 0 ;
32900 int res1 = 0 ;
32901 PyObject *swig_obj[1] ;
32902
32903 if (!args) SWIG_fail;
32904 swig_obj[0] = args;
32905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32906 if (!SWIG_IsOK(res1)) {
32907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32908 }
32909 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32910 {
32911 PyThreadState* __tstate = wxPyBeginAllowThreads();
32912 (arg1)->OnLeave();
32913 wxPyEndAllowThreads(__tstate);
32914 if (PyErr_Occurred()) SWIG_fail;
32915 }
32916 resultobj = SWIG_Py_Void();
32917 return resultobj;
32918 fail:
32919 return NULL;
32920 }
32921
32922
32923 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32924 PyObject *resultobj = 0;
32925 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32926 int arg2 ;
32927 int arg3 ;
32928 bool result;
32929 void *argp1 = 0 ;
32930 int res1 = 0 ;
32931 int val2 ;
32932 int ecode2 = 0 ;
32933 int val3 ;
32934 int ecode3 = 0 ;
32935 PyObject * obj0 = 0 ;
32936 PyObject * obj1 = 0 ;
32937 PyObject * obj2 = 0 ;
32938 char * kwnames[] = {
32939 (char *) "self",(char *) "x",(char *) "y", NULL
32940 };
32941
32942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32944 if (!SWIG_IsOK(res1)) {
32945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32946 }
32947 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32948 ecode2 = SWIG_AsVal_int(obj1, &val2);
32949 if (!SWIG_IsOK(ecode2)) {
32950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
32951 }
32952 arg2 = static_cast< int >(val2);
32953 ecode3 = SWIG_AsVal_int(obj2, &val3);
32954 if (!SWIG_IsOK(ecode3)) {
32955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
32956 }
32957 arg3 = static_cast< int >(val3);
32958 {
32959 PyThreadState* __tstate = wxPyBeginAllowThreads();
32960 result = (bool)(arg1)->OnDrop(arg2,arg3);
32961 wxPyEndAllowThreads(__tstate);
32962 if (PyErr_Occurred()) SWIG_fail;
32963 }
32964 {
32965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32966 }
32967 return resultobj;
32968 fail:
32969 return NULL;
32970 }
32971
32972
32973 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32974 PyObject *resultobj = 0;
32975 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32976 bool result;
32977 void *argp1 = 0 ;
32978 int res1 = 0 ;
32979 PyObject *swig_obj[1] ;
32980
32981 if (!args) SWIG_fail;
32982 swig_obj[0] = args;
32983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32984 if (!SWIG_IsOK(res1)) {
32985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32986 }
32987 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32988 {
32989 PyThreadState* __tstate = wxPyBeginAllowThreads();
32990 result = (bool)(arg1)->GetData();
32991 wxPyEndAllowThreads(__tstate);
32992 if (PyErr_Occurred()) SWIG_fail;
32993 }
32994 {
32995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32996 }
32997 return resultobj;
32998 fail:
32999 return NULL;
33000 }
33001
33002
33003 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33004 PyObject *resultobj = 0;
33005 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33006 wxDragResult arg2 ;
33007 void *argp1 = 0 ;
33008 int res1 = 0 ;
33009 int val2 ;
33010 int ecode2 = 0 ;
33011 PyObject * obj0 = 0 ;
33012 PyObject * obj1 = 0 ;
33013 char * kwnames[] = {
33014 (char *) "self",(char *) "action", NULL
33015 };
33016
33017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33019 if (!SWIG_IsOK(res1)) {
33020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33021 }
33022 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33023 ecode2 = SWIG_AsVal_int(obj1, &val2);
33024 if (!SWIG_IsOK(ecode2)) {
33025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33026 }
33027 arg2 = static_cast< wxDragResult >(val2);
33028 {
33029 PyThreadState* __tstate = wxPyBeginAllowThreads();
33030 (arg1)->SetDefaultAction(arg2);
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 resultobj = SWIG_Py_Void();
33035 return resultobj;
33036 fail:
33037 return NULL;
33038 }
33039
33040
33041 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33042 PyObject *resultobj = 0;
33043 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33044 wxDragResult result;
33045 void *argp1 = 0 ;
33046 int res1 = 0 ;
33047 PyObject *swig_obj[1] ;
33048
33049 if (!args) SWIG_fail;
33050 swig_obj[0] = args;
33051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33052 if (!SWIG_IsOK(res1)) {
33053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33054 }
33055 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 result = (wxDragResult)(arg1)->GetDefaultAction();
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 resultobj = SWIG_From_int(static_cast< int >(result));
33063 return resultobj;
33064 fail:
33065 return NULL;
33066 }
33067
33068
33069 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33070 PyObject *obj;
33071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33072 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33073 return SWIG_Py_Void();
33074 }
33075
33076 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33077 return SWIG_Python_InitShadowInstance(args);
33078 }
33079
33080 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33081 PyObject *resultobj = 0;
33082 wxPyTextDropTarget *result = 0 ;
33083
33084 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33085 {
33086 PyThreadState* __tstate = wxPyBeginAllowThreads();
33087 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33088 wxPyEndAllowThreads(__tstate);
33089 if (PyErr_Occurred()) SWIG_fail;
33090 }
33091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33092 return resultobj;
33093 fail:
33094 return NULL;
33095 }
33096
33097
33098 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33099 PyObject *resultobj = 0;
33100 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33101 PyObject *arg2 = (PyObject *) 0 ;
33102 PyObject *arg3 = (PyObject *) 0 ;
33103 void *argp1 = 0 ;
33104 int res1 = 0 ;
33105 PyObject * obj0 = 0 ;
33106 PyObject * obj1 = 0 ;
33107 PyObject * obj2 = 0 ;
33108 char * kwnames[] = {
33109 (char *) "self",(char *) "self",(char *) "_class", NULL
33110 };
33111
33112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33114 if (!SWIG_IsOK(res1)) {
33115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33116 }
33117 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33118 arg2 = obj1;
33119 arg3 = obj2;
33120 {
33121 PyThreadState* __tstate = wxPyBeginAllowThreads();
33122 (arg1)->_setCallbackInfo(arg2,arg3);
33123 wxPyEndAllowThreads(__tstate);
33124 if (PyErr_Occurred()) SWIG_fail;
33125 }
33126 resultobj = SWIG_Py_Void();
33127 return resultobj;
33128 fail:
33129 return NULL;
33130 }
33131
33132
33133 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33134 PyObject *resultobj = 0;
33135 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33136 int arg2 ;
33137 int arg3 ;
33138 wxString *arg4 = 0 ;
33139 bool result;
33140 void *argp1 = 0 ;
33141 int res1 = 0 ;
33142 int val2 ;
33143 int ecode2 = 0 ;
33144 int val3 ;
33145 int ecode3 = 0 ;
33146 bool temp4 = false ;
33147 PyObject * obj0 = 0 ;
33148 PyObject * obj1 = 0 ;
33149 PyObject * obj2 = 0 ;
33150 PyObject * obj3 = 0 ;
33151 char * kwnames[] = {
33152 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33153 };
33154
33155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33157 if (!SWIG_IsOK(res1)) {
33158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33159 }
33160 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33161 ecode2 = SWIG_AsVal_int(obj1, &val2);
33162 if (!SWIG_IsOK(ecode2)) {
33163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33164 }
33165 arg2 = static_cast< int >(val2);
33166 ecode3 = SWIG_AsVal_int(obj2, &val3);
33167 if (!SWIG_IsOK(ecode3)) {
33168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33169 }
33170 arg3 = static_cast< int >(val3);
33171 {
33172 arg4 = wxString_in_helper(obj3);
33173 if (arg4 == NULL) SWIG_fail;
33174 temp4 = true;
33175 }
33176 {
33177 PyThreadState* __tstate = wxPyBeginAllowThreads();
33178 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33179 wxPyEndAllowThreads(__tstate);
33180 if (PyErr_Occurred()) SWIG_fail;
33181 }
33182 {
33183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33184 }
33185 {
33186 if (temp4)
33187 delete arg4;
33188 }
33189 return resultobj;
33190 fail:
33191 {
33192 if (temp4)
33193 delete arg4;
33194 }
33195 return NULL;
33196 }
33197
33198
33199 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33200 PyObject *resultobj = 0;
33201 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33202 int arg2 ;
33203 int arg3 ;
33204 wxDragResult arg4 ;
33205 wxDragResult result;
33206 void *argp1 = 0 ;
33207 int res1 = 0 ;
33208 int val2 ;
33209 int ecode2 = 0 ;
33210 int val3 ;
33211 int ecode3 = 0 ;
33212 int val4 ;
33213 int ecode4 = 0 ;
33214 PyObject * obj0 = 0 ;
33215 PyObject * obj1 = 0 ;
33216 PyObject * obj2 = 0 ;
33217 PyObject * obj3 = 0 ;
33218 char * kwnames[] = {
33219 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33220 };
33221
33222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33224 if (!SWIG_IsOK(res1)) {
33225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33226 }
33227 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33228 ecode2 = SWIG_AsVal_int(obj1, &val2);
33229 if (!SWIG_IsOK(ecode2)) {
33230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33231 }
33232 arg2 = static_cast< int >(val2);
33233 ecode3 = SWIG_AsVal_int(obj2, &val3);
33234 if (!SWIG_IsOK(ecode3)) {
33235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33236 }
33237 arg3 = static_cast< int >(val3);
33238 ecode4 = SWIG_AsVal_int(obj3, &val4);
33239 if (!SWIG_IsOK(ecode4)) {
33240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33241 }
33242 arg4 = static_cast< wxDragResult >(val4);
33243 {
33244 PyThreadState* __tstate = wxPyBeginAllowThreads();
33245 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 resultobj = SWIG_From_int(static_cast< int >(result));
33250 return resultobj;
33251 fail:
33252 return NULL;
33253 }
33254
33255
33256 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33257 PyObject *resultobj = 0;
33258 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33259 int arg2 ;
33260 int arg3 ;
33261 wxDragResult arg4 ;
33262 wxDragResult result;
33263 void *argp1 = 0 ;
33264 int res1 = 0 ;
33265 int val2 ;
33266 int ecode2 = 0 ;
33267 int val3 ;
33268 int ecode3 = 0 ;
33269 int val4 ;
33270 int ecode4 = 0 ;
33271 PyObject * obj0 = 0 ;
33272 PyObject * obj1 = 0 ;
33273 PyObject * obj2 = 0 ;
33274 PyObject * obj3 = 0 ;
33275 char * kwnames[] = {
33276 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33277 };
33278
33279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33281 if (!SWIG_IsOK(res1)) {
33282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33283 }
33284 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33285 ecode2 = SWIG_AsVal_int(obj1, &val2);
33286 if (!SWIG_IsOK(ecode2)) {
33287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33288 }
33289 arg2 = static_cast< int >(val2);
33290 ecode3 = SWIG_AsVal_int(obj2, &val3);
33291 if (!SWIG_IsOK(ecode3)) {
33292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33293 }
33294 arg3 = static_cast< int >(val3);
33295 ecode4 = SWIG_AsVal_int(obj3, &val4);
33296 if (!SWIG_IsOK(ecode4)) {
33297 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33298 }
33299 arg4 = static_cast< wxDragResult >(val4);
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33303 wxPyEndAllowThreads(__tstate);
33304 if (PyErr_Occurred()) SWIG_fail;
33305 }
33306 resultobj = SWIG_From_int(static_cast< int >(result));
33307 return resultobj;
33308 fail:
33309 return NULL;
33310 }
33311
33312
33313 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33314 PyObject *resultobj = 0;
33315 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33316 void *argp1 = 0 ;
33317 int res1 = 0 ;
33318 PyObject *swig_obj[1] ;
33319
33320 if (!args) SWIG_fail;
33321 swig_obj[0] = args;
33322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33323 if (!SWIG_IsOK(res1)) {
33324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33325 }
33326 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 (arg1)->OnLeave();
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 resultobj = SWIG_Py_Void();
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj = 0;
33342 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33343 int arg2 ;
33344 int arg3 ;
33345 bool result;
33346 void *argp1 = 0 ;
33347 int res1 = 0 ;
33348 int val2 ;
33349 int ecode2 = 0 ;
33350 int val3 ;
33351 int ecode3 = 0 ;
33352 PyObject * obj0 = 0 ;
33353 PyObject * obj1 = 0 ;
33354 PyObject * obj2 = 0 ;
33355 char * kwnames[] = {
33356 (char *) "self",(char *) "x",(char *) "y", NULL
33357 };
33358
33359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33361 if (!SWIG_IsOK(res1)) {
33362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33363 }
33364 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33365 ecode2 = SWIG_AsVal_int(obj1, &val2);
33366 if (!SWIG_IsOK(ecode2)) {
33367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33368 }
33369 arg2 = static_cast< int >(val2);
33370 ecode3 = SWIG_AsVal_int(obj2, &val3);
33371 if (!SWIG_IsOK(ecode3)) {
33372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33373 }
33374 arg3 = static_cast< int >(val3);
33375 {
33376 PyThreadState* __tstate = wxPyBeginAllowThreads();
33377 result = (bool)(arg1)->OnDrop(arg2,arg3);
33378 wxPyEndAllowThreads(__tstate);
33379 if (PyErr_Occurred()) SWIG_fail;
33380 }
33381 {
33382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33383 }
33384 return resultobj;
33385 fail:
33386 return NULL;
33387 }
33388
33389
33390 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33391 PyObject *resultobj = 0;
33392 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33393 int arg2 ;
33394 int arg3 ;
33395 wxDragResult arg4 ;
33396 wxDragResult result;
33397 void *argp1 = 0 ;
33398 int res1 = 0 ;
33399 int val2 ;
33400 int ecode2 = 0 ;
33401 int val3 ;
33402 int ecode3 = 0 ;
33403 int val4 ;
33404 int ecode4 = 0 ;
33405 PyObject * obj0 = 0 ;
33406 PyObject * obj1 = 0 ;
33407 PyObject * obj2 = 0 ;
33408 PyObject * obj3 = 0 ;
33409 char * kwnames[] = {
33410 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33411 };
33412
33413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33415 if (!SWIG_IsOK(res1)) {
33416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33417 }
33418 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33419 ecode2 = SWIG_AsVal_int(obj1, &val2);
33420 if (!SWIG_IsOK(ecode2)) {
33421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33422 }
33423 arg2 = static_cast< int >(val2);
33424 ecode3 = SWIG_AsVal_int(obj2, &val3);
33425 if (!SWIG_IsOK(ecode3)) {
33426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33427 }
33428 arg3 = static_cast< int >(val3);
33429 ecode4 = SWIG_AsVal_int(obj3, &val4);
33430 if (!SWIG_IsOK(ecode4)) {
33431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33432 }
33433 arg4 = static_cast< wxDragResult >(val4);
33434 {
33435 PyThreadState* __tstate = wxPyBeginAllowThreads();
33436 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33437 wxPyEndAllowThreads(__tstate);
33438 if (PyErr_Occurred()) SWIG_fail;
33439 }
33440 resultobj = SWIG_From_int(static_cast< int >(result));
33441 return resultobj;
33442 fail:
33443 return NULL;
33444 }
33445
33446
33447 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33448 PyObject *obj;
33449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33450 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33451 return SWIG_Py_Void();
33452 }
33453
33454 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33455 return SWIG_Python_InitShadowInstance(args);
33456 }
33457
33458 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33459 PyObject *resultobj = 0;
33460 wxPyFileDropTarget *result = 0 ;
33461
33462 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33463 {
33464 PyThreadState* __tstate = wxPyBeginAllowThreads();
33465 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33470 return resultobj;
33471 fail:
33472 return NULL;
33473 }
33474
33475
33476 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33477 PyObject *resultobj = 0;
33478 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33479 PyObject *arg2 = (PyObject *) 0 ;
33480 PyObject *arg3 = (PyObject *) 0 ;
33481 void *argp1 = 0 ;
33482 int res1 = 0 ;
33483 PyObject * obj0 = 0 ;
33484 PyObject * obj1 = 0 ;
33485 PyObject * obj2 = 0 ;
33486 char * kwnames[] = {
33487 (char *) "self",(char *) "self",(char *) "_class", NULL
33488 };
33489
33490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33492 if (!SWIG_IsOK(res1)) {
33493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33494 }
33495 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33496 arg2 = obj1;
33497 arg3 = obj2;
33498 {
33499 PyThreadState* __tstate = wxPyBeginAllowThreads();
33500 (arg1)->_setCallbackInfo(arg2,arg3);
33501 wxPyEndAllowThreads(__tstate);
33502 if (PyErr_Occurred()) SWIG_fail;
33503 }
33504 resultobj = SWIG_Py_Void();
33505 return resultobj;
33506 fail:
33507 return NULL;
33508 }
33509
33510
33511 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33512 PyObject *resultobj = 0;
33513 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33514 int arg2 ;
33515 int arg3 ;
33516 wxArrayString *arg4 = 0 ;
33517 bool result;
33518 void *argp1 = 0 ;
33519 int res1 = 0 ;
33520 int val2 ;
33521 int ecode2 = 0 ;
33522 int val3 ;
33523 int ecode3 = 0 ;
33524 bool temp4 = false ;
33525 PyObject * obj0 = 0 ;
33526 PyObject * obj1 = 0 ;
33527 PyObject * obj2 = 0 ;
33528 PyObject * obj3 = 0 ;
33529 char * kwnames[] = {
33530 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33531 };
33532
33533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33535 if (!SWIG_IsOK(res1)) {
33536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33537 }
33538 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33539 ecode2 = SWIG_AsVal_int(obj1, &val2);
33540 if (!SWIG_IsOK(ecode2)) {
33541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33542 }
33543 arg2 = static_cast< int >(val2);
33544 ecode3 = SWIG_AsVal_int(obj2, &val3);
33545 if (!SWIG_IsOK(ecode3)) {
33546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33547 }
33548 arg3 = static_cast< int >(val3);
33549 {
33550 if (! PySequence_Check(obj3)) {
33551 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33552 SWIG_fail;
33553 }
33554 arg4 = new wxArrayString;
33555 temp4 = true;
33556 int i, len=PySequence_Length(obj3);
33557 for (i=0; i<len; i++) {
33558 PyObject* item = PySequence_GetItem(obj3, i);
33559 wxString* s = wxString_in_helper(item);
33560 if (PyErr_Occurred()) SWIG_fail;
33561 arg4->Add(*s);
33562 delete s;
33563 Py_DECREF(item);
33564 }
33565 }
33566 {
33567 PyThreadState* __tstate = wxPyBeginAllowThreads();
33568 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33569 wxPyEndAllowThreads(__tstate);
33570 if (PyErr_Occurred()) SWIG_fail;
33571 }
33572 {
33573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33574 }
33575 {
33576 if (temp4) delete arg4;
33577 }
33578 return resultobj;
33579 fail:
33580 {
33581 if (temp4) delete arg4;
33582 }
33583 return NULL;
33584 }
33585
33586
33587 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33588 PyObject *resultobj = 0;
33589 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33590 int arg2 ;
33591 int arg3 ;
33592 wxDragResult arg4 ;
33593 wxDragResult result;
33594 void *argp1 = 0 ;
33595 int res1 = 0 ;
33596 int val2 ;
33597 int ecode2 = 0 ;
33598 int val3 ;
33599 int ecode3 = 0 ;
33600 int val4 ;
33601 int ecode4 = 0 ;
33602 PyObject * obj0 = 0 ;
33603 PyObject * obj1 = 0 ;
33604 PyObject * obj2 = 0 ;
33605 PyObject * obj3 = 0 ;
33606 char * kwnames[] = {
33607 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33608 };
33609
33610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33612 if (!SWIG_IsOK(res1)) {
33613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33614 }
33615 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33616 ecode2 = SWIG_AsVal_int(obj1, &val2);
33617 if (!SWIG_IsOK(ecode2)) {
33618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33619 }
33620 arg2 = static_cast< int >(val2);
33621 ecode3 = SWIG_AsVal_int(obj2, &val3);
33622 if (!SWIG_IsOK(ecode3)) {
33623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33624 }
33625 arg3 = static_cast< int >(val3);
33626 ecode4 = SWIG_AsVal_int(obj3, &val4);
33627 if (!SWIG_IsOK(ecode4)) {
33628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33629 }
33630 arg4 = static_cast< wxDragResult >(val4);
33631 {
33632 PyThreadState* __tstate = wxPyBeginAllowThreads();
33633 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33634 wxPyEndAllowThreads(__tstate);
33635 if (PyErr_Occurred()) SWIG_fail;
33636 }
33637 resultobj = SWIG_From_int(static_cast< int >(result));
33638 return resultobj;
33639 fail:
33640 return NULL;
33641 }
33642
33643
33644 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33645 PyObject *resultobj = 0;
33646 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33647 int arg2 ;
33648 int arg3 ;
33649 wxDragResult arg4 ;
33650 wxDragResult result;
33651 void *argp1 = 0 ;
33652 int res1 = 0 ;
33653 int val2 ;
33654 int ecode2 = 0 ;
33655 int val3 ;
33656 int ecode3 = 0 ;
33657 int val4 ;
33658 int ecode4 = 0 ;
33659 PyObject * obj0 = 0 ;
33660 PyObject * obj1 = 0 ;
33661 PyObject * obj2 = 0 ;
33662 PyObject * obj3 = 0 ;
33663 char * kwnames[] = {
33664 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33665 };
33666
33667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33669 if (!SWIG_IsOK(res1)) {
33670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33671 }
33672 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33673 ecode2 = SWIG_AsVal_int(obj1, &val2);
33674 if (!SWIG_IsOK(ecode2)) {
33675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33676 }
33677 arg2 = static_cast< int >(val2);
33678 ecode3 = SWIG_AsVal_int(obj2, &val3);
33679 if (!SWIG_IsOK(ecode3)) {
33680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33681 }
33682 arg3 = static_cast< int >(val3);
33683 ecode4 = SWIG_AsVal_int(obj3, &val4);
33684 if (!SWIG_IsOK(ecode4)) {
33685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33686 }
33687 arg4 = static_cast< wxDragResult >(val4);
33688 {
33689 PyThreadState* __tstate = wxPyBeginAllowThreads();
33690 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33691 wxPyEndAllowThreads(__tstate);
33692 if (PyErr_Occurred()) SWIG_fail;
33693 }
33694 resultobj = SWIG_From_int(static_cast< int >(result));
33695 return resultobj;
33696 fail:
33697 return NULL;
33698 }
33699
33700
33701 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33702 PyObject *resultobj = 0;
33703 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33704 void *argp1 = 0 ;
33705 int res1 = 0 ;
33706 PyObject *swig_obj[1] ;
33707
33708 if (!args) SWIG_fail;
33709 swig_obj[0] = args;
33710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33711 if (!SWIG_IsOK(res1)) {
33712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33713 }
33714 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33715 {
33716 PyThreadState* __tstate = wxPyBeginAllowThreads();
33717 (arg1)->OnLeave();
33718 wxPyEndAllowThreads(__tstate);
33719 if (PyErr_Occurred()) SWIG_fail;
33720 }
33721 resultobj = SWIG_Py_Void();
33722 return resultobj;
33723 fail:
33724 return NULL;
33725 }
33726
33727
33728 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33729 PyObject *resultobj = 0;
33730 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33731 int arg2 ;
33732 int arg3 ;
33733 bool result;
33734 void *argp1 = 0 ;
33735 int res1 = 0 ;
33736 int val2 ;
33737 int ecode2 = 0 ;
33738 int val3 ;
33739 int ecode3 = 0 ;
33740 PyObject * obj0 = 0 ;
33741 PyObject * obj1 = 0 ;
33742 PyObject * obj2 = 0 ;
33743 char * kwnames[] = {
33744 (char *) "self",(char *) "x",(char *) "y", NULL
33745 };
33746
33747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33749 if (!SWIG_IsOK(res1)) {
33750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33751 }
33752 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33753 ecode2 = SWIG_AsVal_int(obj1, &val2);
33754 if (!SWIG_IsOK(ecode2)) {
33755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33756 }
33757 arg2 = static_cast< int >(val2);
33758 ecode3 = SWIG_AsVal_int(obj2, &val3);
33759 if (!SWIG_IsOK(ecode3)) {
33760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33761 }
33762 arg3 = static_cast< int >(val3);
33763 {
33764 PyThreadState* __tstate = wxPyBeginAllowThreads();
33765 result = (bool)(arg1)->OnDrop(arg2,arg3);
33766 wxPyEndAllowThreads(__tstate);
33767 if (PyErr_Occurred()) SWIG_fail;
33768 }
33769 {
33770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33771 }
33772 return resultobj;
33773 fail:
33774 return NULL;
33775 }
33776
33777
33778 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33779 PyObject *resultobj = 0;
33780 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33781 int arg2 ;
33782 int arg3 ;
33783 wxDragResult arg4 ;
33784 wxDragResult result;
33785 void *argp1 = 0 ;
33786 int res1 = 0 ;
33787 int val2 ;
33788 int ecode2 = 0 ;
33789 int val3 ;
33790 int ecode3 = 0 ;
33791 int val4 ;
33792 int ecode4 = 0 ;
33793 PyObject * obj0 = 0 ;
33794 PyObject * obj1 = 0 ;
33795 PyObject * obj2 = 0 ;
33796 PyObject * obj3 = 0 ;
33797 char * kwnames[] = {
33798 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33799 };
33800
33801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33803 if (!SWIG_IsOK(res1)) {
33804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33805 }
33806 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33807 ecode2 = SWIG_AsVal_int(obj1, &val2);
33808 if (!SWIG_IsOK(ecode2)) {
33809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33810 }
33811 arg2 = static_cast< int >(val2);
33812 ecode3 = SWIG_AsVal_int(obj2, &val3);
33813 if (!SWIG_IsOK(ecode3)) {
33814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33815 }
33816 arg3 = static_cast< int >(val3);
33817 ecode4 = SWIG_AsVal_int(obj3, &val4);
33818 if (!SWIG_IsOK(ecode4)) {
33819 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33820 }
33821 arg4 = static_cast< wxDragResult >(val4);
33822 {
33823 PyThreadState* __tstate = wxPyBeginAllowThreads();
33824 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33825 wxPyEndAllowThreads(__tstate);
33826 if (PyErr_Occurred()) SWIG_fail;
33827 }
33828 resultobj = SWIG_From_int(static_cast< int >(result));
33829 return resultobj;
33830 fail:
33831 return NULL;
33832 }
33833
33834
33835 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33836 PyObject *obj;
33837 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33838 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33839 return SWIG_Py_Void();
33840 }
33841
33842 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33843 return SWIG_Python_InitShadowInstance(args);
33844 }
33845
33846 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33847 PyObject *resultobj = 0;
33848 wxClipboard *result = 0 ;
33849
33850 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33851 {
33852 PyThreadState* __tstate = wxPyBeginAllowThreads();
33853 result = (wxClipboard *)new wxClipboard();
33854 wxPyEndAllowThreads(__tstate);
33855 if (PyErr_Occurred()) SWIG_fail;
33856 }
33857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33858 return resultobj;
33859 fail:
33860 return NULL;
33861 }
33862
33863
33864 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33865 PyObject *resultobj = 0;
33866 wxClipboard *arg1 = (wxClipboard *) 0 ;
33867 void *argp1 = 0 ;
33868 int res1 = 0 ;
33869 PyObject *swig_obj[1] ;
33870
33871 if (!args) SWIG_fail;
33872 swig_obj[0] = args;
33873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33874 if (!SWIG_IsOK(res1)) {
33875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33876 }
33877 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33878 {
33879 PyThreadState* __tstate = wxPyBeginAllowThreads();
33880 delete arg1;
33881
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 resultobj = SWIG_Py_Void();
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33893 PyObject *resultobj = 0;
33894 wxClipboard *arg1 = (wxClipboard *) 0 ;
33895 bool result;
33896 void *argp1 = 0 ;
33897 int res1 = 0 ;
33898 PyObject *swig_obj[1] ;
33899
33900 if (!args) SWIG_fail;
33901 swig_obj[0] = args;
33902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33903 if (!SWIG_IsOK(res1)) {
33904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
33905 }
33906 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 result = (bool)(arg1)->Open();
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 {
33914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33915 }
33916 return resultobj;
33917 fail:
33918 return NULL;
33919 }
33920
33921
33922 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33923 PyObject *resultobj = 0;
33924 wxClipboard *arg1 = (wxClipboard *) 0 ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 PyObject *swig_obj[1] ;
33928
33929 if (!args) SWIG_fail;
33930 swig_obj[0] = args;
33931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33932 if (!SWIG_IsOK(res1)) {
33933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
33934 }
33935 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33936 {
33937 PyThreadState* __tstate = wxPyBeginAllowThreads();
33938 (arg1)->Close();
33939 wxPyEndAllowThreads(__tstate);
33940 if (PyErr_Occurred()) SWIG_fail;
33941 }
33942 resultobj = SWIG_Py_Void();
33943 return resultobj;
33944 fail:
33945 return NULL;
33946 }
33947
33948
33949 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33950 PyObject *resultobj = 0;
33951 wxClipboard *arg1 = (wxClipboard *) 0 ;
33952 bool result;
33953 void *argp1 = 0 ;
33954 int res1 = 0 ;
33955 PyObject *swig_obj[1] ;
33956
33957 if (!args) SWIG_fail;
33958 swig_obj[0] = args;
33959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33960 if (!SWIG_IsOK(res1)) {
33961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
33962 }
33963 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33964 {
33965 PyThreadState* __tstate = wxPyBeginAllowThreads();
33966 result = (bool)((wxClipboard const *)arg1)->IsOpened();
33967 wxPyEndAllowThreads(__tstate);
33968 if (PyErr_Occurred()) SWIG_fail;
33969 }
33970 {
33971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33972 }
33973 return resultobj;
33974 fail:
33975 return NULL;
33976 }
33977
33978
33979 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33980 PyObject *resultobj = 0;
33981 wxClipboard *arg1 = (wxClipboard *) 0 ;
33982 wxDataObject *arg2 = (wxDataObject *) 0 ;
33983 bool result;
33984 void *argp1 = 0 ;
33985 int res1 = 0 ;
33986 int res2 = 0 ;
33987 PyObject * obj0 = 0 ;
33988 PyObject * obj1 = 0 ;
33989 char * kwnames[] = {
33990 (char *) "self",(char *) "data", NULL
33991 };
33992
33993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
33994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33995 if (!SWIG_IsOK(res1)) {
33996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
33997 }
33998 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33999 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34000 if (!SWIG_IsOK(res2)) {
34001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34002 }
34003 {
34004 PyThreadState* __tstate = wxPyBeginAllowThreads();
34005 result = (bool)(arg1)->AddData(arg2);
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 {
34010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34011 }
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34019 PyObject *resultobj = 0;
34020 wxClipboard *arg1 = (wxClipboard *) 0 ;
34021 wxDataObject *arg2 = (wxDataObject *) 0 ;
34022 bool result;
34023 void *argp1 = 0 ;
34024 int res1 = 0 ;
34025 int res2 = 0 ;
34026 PyObject * obj0 = 0 ;
34027 PyObject * obj1 = 0 ;
34028 char * kwnames[] = {
34029 (char *) "self",(char *) "data", NULL
34030 };
34031
34032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34034 if (!SWIG_IsOK(res1)) {
34035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34036 }
34037 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34038 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34039 if (!SWIG_IsOK(res2)) {
34040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34041 }
34042 {
34043 PyThreadState* __tstate = wxPyBeginAllowThreads();
34044 result = (bool)(arg1)->SetData(arg2);
34045 wxPyEndAllowThreads(__tstate);
34046 if (PyErr_Occurred()) SWIG_fail;
34047 }
34048 {
34049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34050 }
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34058 PyObject *resultobj = 0;
34059 wxClipboard *arg1 = (wxClipboard *) 0 ;
34060 wxDataFormat *arg2 = 0 ;
34061 bool result;
34062 void *argp1 = 0 ;
34063 int res1 = 0 ;
34064 void *argp2 = 0 ;
34065 int res2 = 0 ;
34066 PyObject * obj0 = 0 ;
34067 PyObject * obj1 = 0 ;
34068 char * kwnames[] = {
34069 (char *) "self",(char *) "format", NULL
34070 };
34071
34072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34074 if (!SWIG_IsOK(res1)) {
34075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34076 }
34077 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34078 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34079 if (!SWIG_IsOK(res2)) {
34080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34081 }
34082 if (!argp2) {
34083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34084 }
34085 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34086 {
34087 PyThreadState* __tstate = wxPyBeginAllowThreads();
34088 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34089 wxPyEndAllowThreads(__tstate);
34090 if (PyErr_Occurred()) SWIG_fail;
34091 }
34092 {
34093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34094 }
34095 return resultobj;
34096 fail:
34097 return NULL;
34098 }
34099
34100
34101 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34102 PyObject *resultobj = 0;
34103 wxClipboard *arg1 = (wxClipboard *) 0 ;
34104 wxDataObject *arg2 = 0 ;
34105 bool result;
34106 void *argp1 = 0 ;
34107 int res1 = 0 ;
34108 void *argp2 = 0 ;
34109 int res2 = 0 ;
34110 PyObject * obj0 = 0 ;
34111 PyObject * obj1 = 0 ;
34112 char * kwnames[] = {
34113 (char *) "self",(char *) "data", NULL
34114 };
34115
34116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34120 }
34121 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34122 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34123 if (!SWIG_IsOK(res2)) {
34124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34125 }
34126 if (!argp2) {
34127 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34128 }
34129 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = (bool)(arg1)->GetData(*arg2);
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 {
34137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34138 }
34139 return resultobj;
34140 fail:
34141 return NULL;
34142 }
34143
34144
34145 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34146 PyObject *resultobj = 0;
34147 wxClipboard *arg1 = (wxClipboard *) 0 ;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 PyObject *swig_obj[1] ;
34151
34152 if (!args) SWIG_fail;
34153 swig_obj[0] = args;
34154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34155 if (!SWIG_IsOK(res1)) {
34156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34157 }
34158 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34159 {
34160 PyThreadState* __tstate = wxPyBeginAllowThreads();
34161 (arg1)->Clear();
34162 wxPyEndAllowThreads(__tstate);
34163 if (PyErr_Occurred()) SWIG_fail;
34164 }
34165 resultobj = SWIG_Py_Void();
34166 return resultobj;
34167 fail:
34168 return NULL;
34169 }
34170
34171
34172 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34173 PyObject *resultobj = 0;
34174 wxClipboard *arg1 = (wxClipboard *) 0 ;
34175 bool result;
34176 void *argp1 = 0 ;
34177 int res1 = 0 ;
34178 PyObject *swig_obj[1] ;
34179
34180 if (!args) SWIG_fail;
34181 swig_obj[0] = args;
34182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34183 if (!SWIG_IsOK(res1)) {
34184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34185 }
34186 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34187 {
34188 PyThreadState* __tstate = wxPyBeginAllowThreads();
34189 result = (bool)(arg1)->Flush();
34190 wxPyEndAllowThreads(__tstate);
34191 if (PyErr_Occurred()) SWIG_fail;
34192 }
34193 {
34194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34195 }
34196 return resultobj;
34197 fail:
34198 return NULL;
34199 }
34200
34201
34202 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34203 PyObject *resultobj = 0;
34204 wxClipboard *arg1 = (wxClipboard *) 0 ;
34205 bool arg2 = (bool) true ;
34206 void *argp1 = 0 ;
34207 int res1 = 0 ;
34208 bool val2 ;
34209 int ecode2 = 0 ;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 char * kwnames[] = {
34213 (char *) "self",(char *) "primary", NULL
34214 };
34215
34216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34220 }
34221 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34222 if (obj1) {
34223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34224 if (!SWIG_IsOK(ecode2)) {
34225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34226 }
34227 arg2 = static_cast< bool >(val2);
34228 }
34229 {
34230 PyThreadState* __tstate = wxPyBeginAllowThreads();
34231 (arg1)->UsePrimarySelection(arg2);
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_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34243 PyObject *resultobj = 0;
34244 wxClipboard *result = 0 ;
34245
34246 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34247 {
34248 PyThreadState* __tstate = wxPyBeginAllowThreads();
34249 result = (wxClipboard *)wxClipboard::Get();
34250 wxPyEndAllowThreads(__tstate);
34251 if (PyErr_Occurred()) SWIG_fail;
34252 }
34253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34254 return resultobj;
34255 fail:
34256 return NULL;
34257 }
34258
34259
34260 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34261 PyObject *obj;
34262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34263 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34264 return SWIG_Py_Void();
34265 }
34266
34267 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34268 return SWIG_Python_InitShadowInstance(args);
34269 }
34270
34271 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34272 PyObject *resultobj = 0;
34273 wxClipboard *arg1 = (wxClipboard *) NULL ;
34274 wxClipboardLocker *result = 0 ;
34275 void *argp1 = 0 ;
34276 int res1 = 0 ;
34277 PyObject * obj0 = 0 ;
34278 char * kwnames[] = {
34279 (char *) "clipboard", NULL
34280 };
34281
34282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34283 if (obj0) {
34284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34285 if (!SWIG_IsOK(res1)) {
34286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34287 }
34288 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34289 }
34290 {
34291 PyThreadState* __tstate = wxPyBeginAllowThreads();
34292 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34293 wxPyEndAllowThreads(__tstate);
34294 if (PyErr_Occurred()) SWIG_fail;
34295 }
34296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34304 PyObject *resultobj = 0;
34305 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34306 void *argp1 = 0 ;
34307 int res1 = 0 ;
34308 PyObject *swig_obj[1] ;
34309
34310 if (!args) SWIG_fail;
34311 swig_obj[0] = args;
34312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34313 if (!SWIG_IsOK(res1)) {
34314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34315 }
34316 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34317 {
34318 PyThreadState* __tstate = wxPyBeginAllowThreads();
34319 delete arg1;
34320
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 resultobj = SWIG_Py_Void();
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34332 PyObject *resultobj = 0;
34333 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34334 bool result;
34335 void *argp1 = 0 ;
34336 int res1 = 0 ;
34337 PyObject *swig_obj[1] ;
34338
34339 if (!args) SWIG_fail;
34340 swig_obj[0] = args;
34341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34342 if (!SWIG_IsOK(res1)) {
34343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34344 }
34345 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34346 {
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 result = (bool)wxClipboardLocker___nonzero__(arg1);
34349 wxPyEndAllowThreads(__tstate);
34350 if (PyErr_Occurred()) SWIG_fail;
34351 }
34352 {
34353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34354 }
34355 return resultobj;
34356 fail:
34357 return NULL;
34358 }
34359
34360
34361 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34362 PyObject *obj;
34363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34364 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34365 return SWIG_Py_Void();
34366 }
34367
34368 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34369 return SWIG_Python_InitShadowInstance(args);
34370 }
34371
34372 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34373 PyObject *resultobj = 0;
34374 int arg1 = (int) 0 ;
34375 int arg2 = (int) 0 ;
34376 int arg3 = (int) 0 ;
34377 int arg4 = (int) 0 ;
34378 wxVideoMode *result = 0 ;
34379 int val1 ;
34380 int ecode1 = 0 ;
34381 int val2 ;
34382 int ecode2 = 0 ;
34383 int val3 ;
34384 int ecode3 = 0 ;
34385 int val4 ;
34386 int ecode4 = 0 ;
34387 PyObject * obj0 = 0 ;
34388 PyObject * obj1 = 0 ;
34389 PyObject * obj2 = 0 ;
34390 PyObject * obj3 = 0 ;
34391 char * kwnames[] = {
34392 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34393 };
34394
34395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34396 if (obj0) {
34397 ecode1 = SWIG_AsVal_int(obj0, &val1);
34398 if (!SWIG_IsOK(ecode1)) {
34399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34400 }
34401 arg1 = static_cast< int >(val1);
34402 }
34403 if (obj1) {
34404 ecode2 = SWIG_AsVal_int(obj1, &val2);
34405 if (!SWIG_IsOK(ecode2)) {
34406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34407 }
34408 arg2 = static_cast< int >(val2);
34409 }
34410 if (obj2) {
34411 ecode3 = SWIG_AsVal_int(obj2, &val3);
34412 if (!SWIG_IsOK(ecode3)) {
34413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34414 }
34415 arg3 = static_cast< int >(val3);
34416 }
34417 if (obj3) {
34418 ecode4 = SWIG_AsVal_int(obj3, &val4);
34419 if (!SWIG_IsOK(ecode4)) {
34420 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34421 }
34422 arg4 = static_cast< int >(val4);
34423 }
34424 {
34425 PyThreadState* __tstate = wxPyBeginAllowThreads();
34426 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34427 wxPyEndAllowThreads(__tstate);
34428 if (PyErr_Occurred()) SWIG_fail;
34429 }
34430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34431 return resultobj;
34432 fail:
34433 return NULL;
34434 }
34435
34436
34437 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34438 PyObject *resultobj = 0;
34439 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34440 void *argp1 = 0 ;
34441 int res1 = 0 ;
34442 PyObject *swig_obj[1] ;
34443
34444 if (!args) SWIG_fail;
34445 swig_obj[0] = args;
34446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34447 if (!SWIG_IsOK(res1)) {
34448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34449 }
34450 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34451 {
34452 PyThreadState* __tstate = wxPyBeginAllowThreads();
34453 delete arg1;
34454
34455 wxPyEndAllowThreads(__tstate);
34456 if (PyErr_Occurred()) SWIG_fail;
34457 }
34458 resultobj = SWIG_Py_Void();
34459 return resultobj;
34460 fail:
34461 return NULL;
34462 }
34463
34464
34465 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34466 PyObject *resultobj = 0;
34467 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34468 wxVideoMode *arg2 = 0 ;
34469 bool result;
34470 void *argp1 = 0 ;
34471 int res1 = 0 ;
34472 void *argp2 = 0 ;
34473 int res2 = 0 ;
34474 PyObject * obj0 = 0 ;
34475 PyObject * obj1 = 0 ;
34476 char * kwnames[] = {
34477 (char *) "self",(char *) "other", NULL
34478 };
34479
34480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34482 if (!SWIG_IsOK(res1)) {
34483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34484 }
34485 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34486 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34487 if (!SWIG_IsOK(res2)) {
34488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34489 }
34490 if (!argp2) {
34491 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34492 }
34493 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34494 {
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34497 wxPyEndAllowThreads(__tstate);
34498 if (PyErr_Occurred()) SWIG_fail;
34499 }
34500 {
34501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34502 }
34503 return resultobj;
34504 fail:
34505 return NULL;
34506 }
34507
34508
34509 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34510 PyObject *resultobj = 0;
34511 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34512 int result;
34513 void *argp1 = 0 ;
34514 int res1 = 0 ;
34515 PyObject *swig_obj[1] ;
34516
34517 if (!args) SWIG_fail;
34518 swig_obj[0] = args;
34519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34520 if (!SWIG_IsOK(res1)) {
34521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34522 }
34523 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34524 {
34525 PyThreadState* __tstate = wxPyBeginAllowThreads();
34526 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34527 wxPyEndAllowThreads(__tstate);
34528 if (PyErr_Occurred()) SWIG_fail;
34529 }
34530 resultobj = SWIG_From_int(static_cast< int >(result));
34531 return resultobj;
34532 fail:
34533 return NULL;
34534 }
34535
34536
34537 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34538 PyObject *resultobj = 0;
34539 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34540 int result;
34541 void *argp1 = 0 ;
34542 int res1 = 0 ;
34543 PyObject *swig_obj[1] ;
34544
34545 if (!args) SWIG_fail;
34546 swig_obj[0] = args;
34547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34548 if (!SWIG_IsOK(res1)) {
34549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34550 }
34551 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34552 {
34553 PyThreadState* __tstate = wxPyBeginAllowThreads();
34554 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34555 wxPyEndAllowThreads(__tstate);
34556 if (PyErr_Occurred()) SWIG_fail;
34557 }
34558 resultobj = SWIG_From_int(static_cast< int >(result));
34559 return resultobj;
34560 fail:
34561 return NULL;
34562 }
34563
34564
34565 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34566 PyObject *resultobj = 0;
34567 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34568 int result;
34569 void *argp1 = 0 ;
34570 int res1 = 0 ;
34571 PyObject *swig_obj[1] ;
34572
34573 if (!args) SWIG_fail;
34574 swig_obj[0] = args;
34575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34576 if (!SWIG_IsOK(res1)) {
34577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34578 }
34579 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34580 {
34581 PyThreadState* __tstate = wxPyBeginAllowThreads();
34582 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34583 wxPyEndAllowThreads(__tstate);
34584 if (PyErr_Occurred()) SWIG_fail;
34585 }
34586 resultobj = SWIG_From_int(static_cast< int >(result));
34587 return resultobj;
34588 fail:
34589 return NULL;
34590 }
34591
34592
34593 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34594 PyObject *resultobj = 0;
34595 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34596 bool result;
34597 void *argp1 = 0 ;
34598 int res1 = 0 ;
34599 PyObject *swig_obj[1] ;
34600
34601 if (!args) SWIG_fail;
34602 swig_obj[0] = args;
34603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34604 if (!SWIG_IsOK(res1)) {
34605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34606 }
34607 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34608 {
34609 PyThreadState* __tstate = wxPyBeginAllowThreads();
34610 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34611 wxPyEndAllowThreads(__tstate);
34612 if (PyErr_Occurred()) SWIG_fail;
34613 }
34614 {
34615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34616 }
34617 return resultobj;
34618 fail:
34619 return NULL;
34620 }
34621
34622
34623 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34624 PyObject *resultobj = 0;
34625 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34626 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34627 bool result;
34628 void *argp1 = 0 ;
34629 int res1 = 0 ;
34630 void *argp2 = 0 ;
34631 int res2 = 0 ;
34632 PyObject * obj0 = 0 ;
34633 PyObject * obj1 = 0 ;
34634 char * kwnames[] = {
34635 (char *) "self",(char *) "other", NULL
34636 };
34637
34638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34640 if (!SWIG_IsOK(res1)) {
34641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34642 }
34643 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34645 if (!SWIG_IsOK(res2)) {
34646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34647 }
34648 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 {
34656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34657 }
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34665 PyObject *resultobj = 0;
34666 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34667 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34668 bool result;
34669 void *argp1 = 0 ;
34670 int res1 = 0 ;
34671 void *argp2 = 0 ;
34672 int res2 = 0 ;
34673 PyObject * obj0 = 0 ;
34674 PyObject * obj1 = 0 ;
34675 char * kwnames[] = {
34676 (char *) "self",(char *) "other", NULL
34677 };
34678
34679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34681 if (!SWIG_IsOK(res1)) {
34682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34683 }
34684 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34686 if (!SWIG_IsOK(res2)) {
34687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34688 }
34689 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34693 wxPyEndAllowThreads(__tstate);
34694 if (PyErr_Occurred()) SWIG_fail;
34695 }
34696 {
34697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34698 }
34699 return resultobj;
34700 fail:
34701 return NULL;
34702 }
34703
34704
34705 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34706 PyObject *resultobj = 0;
34707 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34708 int arg2 ;
34709 void *argp1 = 0 ;
34710 int res1 = 0 ;
34711 int val2 ;
34712 int ecode2 = 0 ;
34713 PyObject *swig_obj[2] ;
34714
34715 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34717 if (!SWIG_IsOK(res1)) {
34718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34719 }
34720 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34721 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34722 if (!SWIG_IsOK(ecode2)) {
34723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34724 }
34725 arg2 = static_cast< int >(val2);
34726 if (arg1) (arg1)->w = arg2;
34727
34728 resultobj = SWIG_Py_Void();
34729 return resultobj;
34730 fail:
34731 return NULL;
34732 }
34733
34734
34735 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34736 PyObject *resultobj = 0;
34737 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34738 int result;
34739 void *argp1 = 0 ;
34740 int res1 = 0 ;
34741 PyObject *swig_obj[1] ;
34742
34743 if (!args) SWIG_fail;
34744 swig_obj[0] = args;
34745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34746 if (!SWIG_IsOK(res1)) {
34747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34748 }
34749 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34750 result = (int) ((arg1)->w);
34751 resultobj = SWIG_From_int(static_cast< int >(result));
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34759 PyObject *resultobj = 0;
34760 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34761 int arg2 ;
34762 void *argp1 = 0 ;
34763 int res1 = 0 ;
34764 int val2 ;
34765 int ecode2 = 0 ;
34766 PyObject *swig_obj[2] ;
34767
34768 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34770 if (!SWIG_IsOK(res1)) {
34771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34772 }
34773 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34774 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34775 if (!SWIG_IsOK(ecode2)) {
34776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34777 }
34778 arg2 = static_cast< int >(val2);
34779 if (arg1) (arg1)->h = arg2;
34780
34781 resultobj = SWIG_Py_Void();
34782 return resultobj;
34783 fail:
34784 return NULL;
34785 }
34786
34787
34788 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34789 PyObject *resultobj = 0;
34790 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34791 int result;
34792 void *argp1 = 0 ;
34793 int res1 = 0 ;
34794 PyObject *swig_obj[1] ;
34795
34796 if (!args) SWIG_fail;
34797 swig_obj[0] = args;
34798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34799 if (!SWIG_IsOK(res1)) {
34800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34801 }
34802 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34803 result = (int) ((arg1)->h);
34804 resultobj = SWIG_From_int(static_cast< int >(result));
34805 return resultobj;
34806 fail:
34807 return NULL;
34808 }
34809
34810
34811 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34812 PyObject *resultobj = 0;
34813 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34814 int arg2 ;
34815 void *argp1 = 0 ;
34816 int res1 = 0 ;
34817 int val2 ;
34818 int ecode2 = 0 ;
34819 PyObject *swig_obj[2] ;
34820
34821 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34823 if (!SWIG_IsOK(res1)) {
34824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34825 }
34826 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34827 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34828 if (!SWIG_IsOK(ecode2)) {
34829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34830 }
34831 arg2 = static_cast< int >(val2);
34832 if (arg1) (arg1)->bpp = arg2;
34833
34834 resultobj = SWIG_Py_Void();
34835 return resultobj;
34836 fail:
34837 return NULL;
34838 }
34839
34840
34841 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34842 PyObject *resultobj = 0;
34843 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34844 int result;
34845 void *argp1 = 0 ;
34846 int res1 = 0 ;
34847 PyObject *swig_obj[1] ;
34848
34849 if (!args) SWIG_fail;
34850 swig_obj[0] = args;
34851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34852 if (!SWIG_IsOK(res1)) {
34853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34854 }
34855 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34856 result = (int) ((arg1)->bpp);
34857 resultobj = SWIG_From_int(static_cast< int >(result));
34858 return resultobj;
34859 fail:
34860 return NULL;
34861 }
34862
34863
34864 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34865 PyObject *resultobj = 0;
34866 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34867 int arg2 ;
34868 void *argp1 = 0 ;
34869 int res1 = 0 ;
34870 int val2 ;
34871 int ecode2 = 0 ;
34872 PyObject *swig_obj[2] ;
34873
34874 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
34875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34876 if (!SWIG_IsOK(res1)) {
34877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34878 }
34879 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34880 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34881 if (!SWIG_IsOK(ecode2)) {
34882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34883 }
34884 arg2 = static_cast< int >(val2);
34885 if (arg1) (arg1)->refresh = arg2;
34886
34887 resultobj = SWIG_Py_Void();
34888 return resultobj;
34889 fail:
34890 return NULL;
34891 }
34892
34893
34894 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34895 PyObject *resultobj = 0;
34896 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34897 int result;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 PyObject *swig_obj[1] ;
34901
34902 if (!args) SWIG_fail;
34903 swig_obj[0] = args;
34904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34905 if (!SWIG_IsOK(res1)) {
34906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34907 }
34908 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34909 result = (int) ((arg1)->refresh);
34910 resultobj = SWIG_From_int(static_cast< int >(result));
34911 return resultobj;
34912 fail:
34913 return NULL;
34914 }
34915
34916
34917 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34918 PyObject *obj;
34919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34920 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
34921 return SWIG_Py_Void();
34922 }
34923
34924 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34925 return SWIG_Python_InitShadowInstance(args);
34926 }
34927
34928 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
34929 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
34930 return 1;
34931 }
34932
34933
34934 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
34935 PyObject *pyobj = 0;
34936
34937 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
34938 return pyobj;
34939 }
34940
34941
34942 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34943 PyObject *resultobj = 0;
34944 size_t arg1 = (size_t) 0 ;
34945 wxDisplay *result = 0 ;
34946 size_t val1 ;
34947 int ecode1 = 0 ;
34948 PyObject * obj0 = 0 ;
34949 char * kwnames[] = {
34950 (char *) "index", NULL
34951 };
34952
34953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
34954 if (obj0) {
34955 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
34956 if (!SWIG_IsOK(ecode1)) {
34957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
34958 }
34959 arg1 = static_cast< size_t >(val1);
34960 }
34961 {
34962 PyThreadState* __tstate = wxPyBeginAllowThreads();
34963 result = (wxDisplay *)new wxDisplay(arg1);
34964 wxPyEndAllowThreads(__tstate);
34965 if (PyErr_Occurred()) SWIG_fail;
34966 }
34967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
34968 return resultobj;
34969 fail:
34970 return NULL;
34971 }
34972
34973
34974 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34975 PyObject *resultobj = 0;
34976 wxDisplay *arg1 = (wxDisplay *) 0 ;
34977 void *argp1 = 0 ;
34978 int res1 = 0 ;
34979 PyObject *swig_obj[1] ;
34980
34981 if (!args) SWIG_fail;
34982 swig_obj[0] = args;
34983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
34984 if (!SWIG_IsOK(res1)) {
34985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
34986 }
34987 arg1 = reinterpret_cast< wxDisplay * >(argp1);
34988 {
34989 PyThreadState* __tstate = wxPyBeginAllowThreads();
34990 delete arg1;
34991
34992 wxPyEndAllowThreads(__tstate);
34993 if (PyErr_Occurred()) SWIG_fail;
34994 }
34995 resultobj = SWIG_Py_Void();
34996 return resultobj;
34997 fail:
34998 return NULL;
34999 }
35000
35001
35002 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35003 PyObject *resultobj = 0;
35004 size_t result;
35005
35006 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35007 {
35008 PyThreadState* __tstate = wxPyBeginAllowThreads();
35009 result = (size_t)wxDisplay::GetCount();
35010 wxPyEndAllowThreads(__tstate);
35011 if (PyErr_Occurred()) SWIG_fail;
35012 }
35013 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35021 PyObject *resultobj = 0;
35022 wxPoint *arg1 = 0 ;
35023 int result;
35024 wxPoint temp1 ;
35025 PyObject * obj0 = 0 ;
35026 char * kwnames[] = {
35027 (char *) "pt", NULL
35028 };
35029
35030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35031 {
35032 arg1 = &temp1;
35033 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35034 }
35035 {
35036 PyThreadState* __tstate = wxPyBeginAllowThreads();
35037 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35038 wxPyEndAllowThreads(__tstate);
35039 if (PyErr_Occurred()) SWIG_fail;
35040 }
35041 resultobj = SWIG_From_int(static_cast< int >(result));
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj = 0;
35050 wxWindow *arg1 = (wxWindow *) 0 ;
35051 int result;
35052 void *argp1 = 0 ;
35053 int res1 = 0 ;
35054 PyObject * obj0 = 0 ;
35055 char * kwnames[] = {
35056 (char *) "window", NULL
35057 };
35058
35059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35061 if (!SWIG_IsOK(res1)) {
35062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35063 }
35064 arg1 = reinterpret_cast< wxWindow * >(argp1);
35065 {
35066 PyThreadState* __tstate = wxPyBeginAllowThreads();
35067 result = (int)wxDisplay::GetFromWindow(arg1);
35068 wxPyEndAllowThreads(__tstate);
35069 if (PyErr_Occurred()) SWIG_fail;
35070 }
35071 resultobj = SWIG_From_int(static_cast< int >(result));
35072 return resultobj;
35073 fail:
35074 return NULL;
35075 }
35076
35077
35078 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35079 PyObject *resultobj = 0;
35080 wxDisplay *arg1 = (wxDisplay *) 0 ;
35081 bool result;
35082 void *argp1 = 0 ;
35083 int res1 = 0 ;
35084 PyObject *swig_obj[1] ;
35085
35086 if (!args) SWIG_fail;
35087 swig_obj[0] = args;
35088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35089 if (!SWIG_IsOK(res1)) {
35090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35091 }
35092 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35093 {
35094 PyThreadState* __tstate = wxPyBeginAllowThreads();
35095 result = (bool)((wxDisplay const *)arg1)->IsOk();
35096 wxPyEndAllowThreads(__tstate);
35097 if (PyErr_Occurred()) SWIG_fail;
35098 }
35099 {
35100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35101 }
35102 return resultobj;
35103 fail:
35104 return NULL;
35105 }
35106
35107
35108 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35109 PyObject *resultobj = 0;
35110 wxDisplay *arg1 = (wxDisplay *) 0 ;
35111 wxRect result;
35112 void *argp1 = 0 ;
35113 int res1 = 0 ;
35114 PyObject *swig_obj[1] ;
35115
35116 if (!args) SWIG_fail;
35117 swig_obj[0] = args;
35118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35119 if (!SWIG_IsOK(res1)) {
35120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35121 }
35122 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35123 {
35124 PyThreadState* __tstate = wxPyBeginAllowThreads();
35125 result = ((wxDisplay const *)arg1)->GetGeometry();
35126 wxPyEndAllowThreads(__tstate);
35127 if (PyErr_Occurred()) SWIG_fail;
35128 }
35129 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35130 return resultobj;
35131 fail:
35132 return NULL;
35133 }
35134
35135
35136 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35137 PyObject *resultobj = 0;
35138 wxDisplay *arg1 = (wxDisplay *) 0 ;
35139 wxString result;
35140 void *argp1 = 0 ;
35141 int res1 = 0 ;
35142 PyObject *swig_obj[1] ;
35143
35144 if (!args) SWIG_fail;
35145 swig_obj[0] = args;
35146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35147 if (!SWIG_IsOK(res1)) {
35148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35149 }
35150 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35151 {
35152 PyThreadState* __tstate = wxPyBeginAllowThreads();
35153 result = ((wxDisplay const *)arg1)->GetName();
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 {
35158 #if wxUSE_UNICODE
35159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35160 #else
35161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35162 #endif
35163 }
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35171 PyObject *resultobj = 0;
35172 wxDisplay *arg1 = (wxDisplay *) 0 ;
35173 bool result;
35174 void *argp1 = 0 ;
35175 int res1 = 0 ;
35176 PyObject *swig_obj[1] ;
35177
35178 if (!args) SWIG_fail;
35179 swig_obj[0] = args;
35180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35183 }
35184 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35185 {
35186 PyThreadState* __tstate = wxPyBeginAllowThreads();
35187 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35188 wxPyEndAllowThreads(__tstate);
35189 if (PyErr_Occurred()) SWIG_fail;
35190 }
35191 {
35192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35193 }
35194 return resultobj;
35195 fail:
35196 return NULL;
35197 }
35198
35199
35200 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35201 PyObject *resultobj = 0;
35202 wxDisplay *arg1 = (wxDisplay *) 0 ;
35203 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35204 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35205 PyObject *result = 0 ;
35206 void *argp1 = 0 ;
35207 int res1 = 0 ;
35208 void *argp2 = 0 ;
35209 int res2 = 0 ;
35210 PyObject * obj0 = 0 ;
35211 PyObject * obj1 = 0 ;
35212 char * kwnames[] = {
35213 (char *) "self",(char *) "mode", NULL
35214 };
35215
35216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35218 if (!SWIG_IsOK(res1)) {
35219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35220 }
35221 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35222 if (obj1) {
35223 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35224 if (!SWIG_IsOK(res2)) {
35225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35226 }
35227 if (!argp2) {
35228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35229 }
35230 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35231 }
35232 {
35233 PyThreadState* __tstate = wxPyBeginAllowThreads();
35234 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35235 wxPyEndAllowThreads(__tstate);
35236 if (PyErr_Occurred()) SWIG_fail;
35237 }
35238 resultobj = result;
35239 return resultobj;
35240 fail:
35241 return NULL;
35242 }
35243
35244
35245 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35246 PyObject *resultobj = 0;
35247 wxDisplay *arg1 = (wxDisplay *) 0 ;
35248 wxVideoMode result;
35249 void *argp1 = 0 ;
35250 int res1 = 0 ;
35251 PyObject *swig_obj[1] ;
35252
35253 if (!args) SWIG_fail;
35254 swig_obj[0] = args;
35255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35256 if (!SWIG_IsOK(res1)) {
35257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35258 }
35259 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35260 {
35261 PyThreadState* __tstate = wxPyBeginAllowThreads();
35262 result = ((wxDisplay const *)arg1)->GetCurrentMode();
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35267 return resultobj;
35268 fail:
35269 return NULL;
35270 }
35271
35272
35273 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35274 PyObject *resultobj = 0;
35275 wxDisplay *arg1 = (wxDisplay *) 0 ;
35276 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35277 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35278 bool result;
35279 void *argp1 = 0 ;
35280 int res1 = 0 ;
35281 void *argp2 = 0 ;
35282 int res2 = 0 ;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char * kwnames[] = {
35286 (char *) "self",(char *) "mode", NULL
35287 };
35288
35289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35291 if (!SWIG_IsOK(res1)) {
35292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35293 }
35294 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35295 if (obj1) {
35296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35297 if (!SWIG_IsOK(res2)) {
35298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35299 }
35300 if (!argp2) {
35301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35302 }
35303 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35304 }
35305 {
35306 PyThreadState* __tstate = wxPyBeginAllowThreads();
35307 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
35308 wxPyEndAllowThreads(__tstate);
35309 if (PyErr_Occurred()) SWIG_fail;
35310 }
35311 {
35312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35313 }
35314 return resultobj;
35315 fail:
35316 return NULL;
35317 }
35318
35319
35320 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35321 PyObject *resultobj = 0;
35322 wxDisplay *arg1 = (wxDisplay *) 0 ;
35323 void *argp1 = 0 ;
35324 int res1 = 0 ;
35325 PyObject *swig_obj[1] ;
35326
35327 if (!args) SWIG_fail;
35328 swig_obj[0] = args;
35329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35330 if (!SWIG_IsOK(res1)) {
35331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35332 }
35333 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35334 {
35335 PyThreadState* __tstate = wxPyBeginAllowThreads();
35336 (arg1)->ResetMode();
35337 wxPyEndAllowThreads(__tstate);
35338 if (PyErr_Occurred()) SWIG_fail;
35339 }
35340 resultobj = SWIG_Py_Void();
35341 return resultobj;
35342 fail:
35343 return NULL;
35344 }
35345
35346
35347 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35348 PyObject *obj;
35349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35350 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35351 return SWIG_Py_Void();
35352 }
35353
35354 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35355 return SWIG_Python_InitShadowInstance(args);
35356 }
35357
35358 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35359 PyObject *resultobj = 0;
35360 wxStandardPaths *result = 0 ;
35361
35362 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35363 {
35364 PyThreadState* __tstate = wxPyBeginAllowThreads();
35365 result = (wxStandardPaths *)wxStandardPaths_Get();
35366 wxPyEndAllowThreads(__tstate);
35367 if (PyErr_Occurred()) SWIG_fail;
35368 }
35369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35370 return resultobj;
35371 fail:
35372 return NULL;
35373 }
35374
35375
35376 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35377 PyObject *resultobj = 0;
35378 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35379 wxString result;
35380 void *argp1 = 0 ;
35381 int res1 = 0 ;
35382 PyObject *swig_obj[1] ;
35383
35384 if (!args) SWIG_fail;
35385 swig_obj[0] = args;
35386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35387 if (!SWIG_IsOK(res1)) {
35388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35389 }
35390 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35391 {
35392 PyThreadState* __tstate = wxPyBeginAllowThreads();
35393 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35394 wxPyEndAllowThreads(__tstate);
35395 if (PyErr_Occurred()) SWIG_fail;
35396 }
35397 {
35398 #if wxUSE_UNICODE
35399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35400 #else
35401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35402 #endif
35403 }
35404 return resultobj;
35405 fail:
35406 return NULL;
35407 }
35408
35409
35410 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35411 PyObject *resultobj = 0;
35412 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35413 wxString result;
35414 void *argp1 = 0 ;
35415 int res1 = 0 ;
35416 PyObject *swig_obj[1] ;
35417
35418 if (!args) SWIG_fail;
35419 swig_obj[0] = args;
35420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35421 if (!SWIG_IsOK(res1)) {
35422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35423 }
35424 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35425 {
35426 PyThreadState* __tstate = wxPyBeginAllowThreads();
35427 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35428 wxPyEndAllowThreads(__tstate);
35429 if (PyErr_Occurred()) SWIG_fail;
35430 }
35431 {
35432 #if wxUSE_UNICODE
35433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35434 #else
35435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35436 #endif
35437 }
35438 return resultobj;
35439 fail:
35440 return NULL;
35441 }
35442
35443
35444 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35445 PyObject *resultobj = 0;
35446 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35447 wxString result;
35448 void *argp1 = 0 ;
35449 int res1 = 0 ;
35450 PyObject *swig_obj[1] ;
35451
35452 if (!args) SWIG_fail;
35453 swig_obj[0] = args;
35454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35455 if (!SWIG_IsOK(res1)) {
35456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35457 }
35458 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35459 {
35460 PyThreadState* __tstate = wxPyBeginAllowThreads();
35461 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35462 wxPyEndAllowThreads(__tstate);
35463 if (PyErr_Occurred()) SWIG_fail;
35464 }
35465 {
35466 #if wxUSE_UNICODE
35467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35468 #else
35469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35470 #endif
35471 }
35472 return resultobj;
35473 fail:
35474 return NULL;
35475 }
35476
35477
35478 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35479 PyObject *resultobj = 0;
35480 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35481 wxString result;
35482 void *argp1 = 0 ;
35483 int res1 = 0 ;
35484 PyObject *swig_obj[1] ;
35485
35486 if (!args) SWIG_fail;
35487 swig_obj[0] = args;
35488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35489 if (!SWIG_IsOK(res1)) {
35490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35491 }
35492 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35493 {
35494 PyThreadState* __tstate = wxPyBeginAllowThreads();
35495 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35496 wxPyEndAllowThreads(__tstate);
35497 if (PyErr_Occurred()) SWIG_fail;
35498 }
35499 {
35500 #if wxUSE_UNICODE
35501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35502 #else
35503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35504 #endif
35505 }
35506 return resultobj;
35507 fail:
35508 return NULL;
35509 }
35510
35511
35512 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35513 PyObject *resultobj = 0;
35514 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35515 wxString result;
35516 void *argp1 = 0 ;
35517 int res1 = 0 ;
35518 PyObject *swig_obj[1] ;
35519
35520 if (!args) SWIG_fail;
35521 swig_obj[0] = args;
35522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35523 if (!SWIG_IsOK(res1)) {
35524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35525 }
35526 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35527 {
35528 PyThreadState* __tstate = wxPyBeginAllowThreads();
35529 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35530 wxPyEndAllowThreads(__tstate);
35531 if (PyErr_Occurred()) SWIG_fail;
35532 }
35533 {
35534 #if wxUSE_UNICODE
35535 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35536 #else
35537 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35538 #endif
35539 }
35540 return resultobj;
35541 fail:
35542 return NULL;
35543 }
35544
35545
35546 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35547 PyObject *resultobj = 0;
35548 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35549 wxString result;
35550 void *argp1 = 0 ;
35551 int res1 = 0 ;
35552 PyObject *swig_obj[1] ;
35553
35554 if (!args) SWIG_fail;
35555 swig_obj[0] = args;
35556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35557 if (!SWIG_IsOK(res1)) {
35558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35559 }
35560 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35561 {
35562 PyThreadState* __tstate = wxPyBeginAllowThreads();
35563 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35564 wxPyEndAllowThreads(__tstate);
35565 if (PyErr_Occurred()) SWIG_fail;
35566 }
35567 {
35568 #if wxUSE_UNICODE
35569 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35570 #else
35571 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35572 #endif
35573 }
35574 return resultobj;
35575 fail:
35576 return NULL;
35577 }
35578
35579
35580 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35581 PyObject *resultobj = 0;
35582 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35583 wxString result;
35584 void *argp1 = 0 ;
35585 int res1 = 0 ;
35586 PyObject *swig_obj[1] ;
35587
35588 if (!args) SWIG_fail;
35589 swig_obj[0] = args;
35590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35591 if (!SWIG_IsOK(res1)) {
35592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35593 }
35594 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35595 {
35596 PyThreadState* __tstate = wxPyBeginAllowThreads();
35597 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35598 wxPyEndAllowThreads(__tstate);
35599 if (PyErr_Occurred()) SWIG_fail;
35600 }
35601 {
35602 #if wxUSE_UNICODE
35603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35604 #else
35605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35606 #endif
35607 }
35608 return resultobj;
35609 fail:
35610 return NULL;
35611 }
35612
35613
35614 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35615 PyObject *resultobj = 0;
35616 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35617 wxString *arg2 = 0 ;
35618 void *argp1 = 0 ;
35619 int res1 = 0 ;
35620 bool temp2 = false ;
35621 PyObject * obj0 = 0 ;
35622 PyObject * obj1 = 0 ;
35623 char * kwnames[] = {
35624 (char *) "self",(char *) "prefix", NULL
35625 };
35626
35627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35629 if (!SWIG_IsOK(res1)) {
35630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35631 }
35632 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35633 {
35634 arg2 = wxString_in_helper(obj1);
35635 if (arg2 == NULL) SWIG_fail;
35636 temp2 = true;
35637 }
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 (arg1)->SetInstallPrefix((wxString const &)*arg2);
35641 wxPyEndAllowThreads(__tstate);
35642 if (PyErr_Occurred()) SWIG_fail;
35643 }
35644 resultobj = SWIG_Py_Void();
35645 {
35646 if (temp2)
35647 delete arg2;
35648 }
35649 return resultobj;
35650 fail:
35651 {
35652 if (temp2)
35653 delete arg2;
35654 }
35655 return NULL;
35656 }
35657
35658
35659 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35660 PyObject *resultobj = 0;
35661 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35662 wxString result;
35663 void *argp1 = 0 ;
35664 int res1 = 0 ;
35665 PyObject *swig_obj[1] ;
35666
35667 if (!args) SWIG_fail;
35668 swig_obj[0] = args;
35669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35670 if (!SWIG_IsOK(res1)) {
35671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35672 }
35673 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35674 {
35675 PyThreadState* __tstate = wxPyBeginAllowThreads();
35676 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
35677 wxPyEndAllowThreads(__tstate);
35678 if (PyErr_Occurred()) SWIG_fail;
35679 }
35680 {
35681 #if wxUSE_UNICODE
35682 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35683 #else
35684 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35685 #endif
35686 }
35687 return resultobj;
35688 fail:
35689 return NULL;
35690 }
35691
35692
35693 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35694 PyObject *obj;
35695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35696 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35697 return SWIG_Py_Void();
35698 }
35699
35700 static PyMethodDef SwigMethods[] = {
35701 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
35702 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35703 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
35704 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
35705 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
35706 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
35707 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
35708 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
35709 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35710 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35711 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35712 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35713 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
35714 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
35715 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
35716 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
35717 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
35718 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
35719 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
35720 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
35721 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35722 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35723 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
35724 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
35725 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
35726 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
35727 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
35728 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
35729 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
35730 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
35731 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
35732 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
35733 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
35734 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
35735 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35736 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35737 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
35738 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
35739 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
35740 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
35741 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
35742 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
35743 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
35744 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
35745 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
35746 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
35747 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
35748 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35749 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35750 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35751 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35752 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35753 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35754 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
35755 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35756 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
35757 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
35758 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
35759 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
35760 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
35761 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
35762 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
35763 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
35764 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
35765 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
35766 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35767 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
35768 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35769 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
35770 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
35771 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
35772 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35773 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35774 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
35775 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
35776 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
35777 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
35778 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
35779 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
35780 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
35781 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
35782 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
35783 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
35784 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
35785 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
35786 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
35787 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
35788 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
35789 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
35790 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
35791 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
35792 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
35793 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
35794 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
35795 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
35796 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
35797 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
35798 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
35799 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
35800 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
35801 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
35802 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
35803 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
35804 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
35805 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
35806 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
35807 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
35808 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
35809 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
35810 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
35811 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
35812 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
35813 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
35814 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
35815 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
35816 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
35817 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
35818 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
35819 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
35820 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
35821 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
35822 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
35823 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
35824 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
35825 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
35826 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
35827 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
35828 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
35829 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
35830 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
35831 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
35832 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
35833 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
35834 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
35835 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
35836 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
35837 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
35838 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35839 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
35840 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
35841 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
35842 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
35843 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
35844 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
35845 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
35846 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35847 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
35848 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
35849 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
35850 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
35851 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35852 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
35853 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
35854 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
35855 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
35856 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
35857 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35858 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
35859 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35860 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35861 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
35862 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35863 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35864 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
35865 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
35866 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
35867 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35868 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
35869 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
35870 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
35871 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
35872 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
35873 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
35874 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
35875 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35876 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
35877 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
35878 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
35879 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
35880 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
35881 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
35882 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
35883 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
35884 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
35885 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35886 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35887 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
35888 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
35889 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
35890 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35891 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
35892 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
35893 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35894 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
35895 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
35896 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35897 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
35898 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
35899 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
35900 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
35901 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
35902 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
35903 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
35904 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
35905 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35906 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
35907 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
35908 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
35909 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
35910 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
35911 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35912 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
35913 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
35914 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
35915 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
35916 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
35917 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
35918 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
35919 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
35920 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
35921 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
35922 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
35923 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
35924 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
35925 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
35926 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
35927 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
35928 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35929 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35930 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35931 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
35932 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
35933 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
35934 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
35935 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
35936 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35937 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
35938 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
35939 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
35940 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
35941 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
35942 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
35943 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
35944 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
35945 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
35946 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35947 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
35948 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
35949 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
35950 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
35951 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
35952 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35953 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
35954 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
35955 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
35956 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
35957 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
35958 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
35959 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
35960 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
35961 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
35962 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
35963 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
35964 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
35965 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
35966 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
35967 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
35968 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
35969 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
35970 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
35971 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
35972 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
35973 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
35974 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
35975 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
35976 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
35977 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35978 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
35979 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
35980 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
35981 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
35982 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
35983 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
35984 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
35985 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
35986 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
35987 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
35988 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
35989 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
35990 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
35991 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35992 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
35993 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
35994 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
35995 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
35996 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
35997 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
35998 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35999 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36000 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36001 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36002 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36003 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36004 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36005 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36006 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36007 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36008 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36009 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36010 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36011 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36012 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36013 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36014 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36015 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36016 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36017 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36018 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36019 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36020 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36021 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36022 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36023 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36024 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36025 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36026 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36027 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36028 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36029 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36030 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36031 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36032 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36033 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36034 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36035 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36036 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36037 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36038 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36039 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36040 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36041 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36042 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36043 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36044 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36045 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36046 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36047 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36048 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36049 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36050 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36051 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36052 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36053 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36054 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36055 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36056 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36057 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36058 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36059 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36060 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36061 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36062 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36063 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36064 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36065 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36066 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36067 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36068 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36069 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36070 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36071 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36072 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36073 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36074 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36075 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36076 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36077 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36078 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36079 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36080 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36081 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36082 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36083 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36084 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36085 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36086 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36087 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36088 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36089 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36090 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36091 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36092 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36093 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36094 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36095 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36096 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36097 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36098 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36099 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36100 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36101 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36102 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36103 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36104 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36105 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36106 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36107 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36108 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36109 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36110 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36111 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36112 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36113 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36114 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36115 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36116 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36117 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36118 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36119 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36120 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36121 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36122 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36123 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36124 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36125 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36126 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36127 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36128 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36129 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36130 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36131 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36132 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36133 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36134 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36135 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36136 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36137 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36138 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36139 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36140 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36141 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36142 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36143 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36144 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36145 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36146 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36147 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36148 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36149 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36150 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36151 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36152 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36153 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36154 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36156 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36158 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36159 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36160 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36161 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36163 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36164 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36165 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36167 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36168 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36169 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36170 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36171 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36172 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36173 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36174 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36175 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36177 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36178 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36179 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36180 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36182 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36183 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36184 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36185 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36186 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36187 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36188 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36189 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36190 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36191 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36192 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36193 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36194 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36195 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36196 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36197 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36198 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36199 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36200 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36201 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36202 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36203 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36204 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36205 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36206 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36207 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36209 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36210 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36211 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36213 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36214 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36215 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36216 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36217 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36219 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36221 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36222 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36224 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36225 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36226 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36227 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36228 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36229 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36230 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36231 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36232 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36233 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36234 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36235 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36236 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36237 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36238 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36239 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36240 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36241 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36243 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36244 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36245 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36246 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36247 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36248 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36249 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36250 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36253 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36254 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36255 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36256 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36257 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36258 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36259 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36260 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36261 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36263 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36264 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36265 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36267 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36268 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36270 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36271 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36273 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36274 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36275 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36276 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36277 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36280 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36281 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36282 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36289 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36290 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36291 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36292 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36293 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36294 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36295 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36296 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36297 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36298 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36302 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36309 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36310 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36316 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36317 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36318 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36319 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36326 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36331 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36332 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36333 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36334 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36335 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36336 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36337 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36339 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36341 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36343 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36345 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36347 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36349 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36350 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36351 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36352 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36353 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36354 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36357 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36358 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36369 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36370 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36371 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36375 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36376 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36377 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36378 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36379 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36380 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36382 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36383 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36385 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36386 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36387 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36388 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36389 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36391 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36392 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36393 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36396 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36397 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36398 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36399 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36400 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36401 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36402 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36405 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36409 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36410 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36411 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36412 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36413 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36414 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36417 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36418 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36419 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36420 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36421 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36422 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36425 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36426 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36427 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36429 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36430 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36432 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36433 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36434 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36436 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36437 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36438 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36440 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36442 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36444 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36446 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36447 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36448 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36449 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36450 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36451 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36453 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36454 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36455 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36457 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36458 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36460 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36461 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36463 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36464 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36467 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36468 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36470 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36472 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36473 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36476 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36477 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36478 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36479 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36480 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36481 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36482 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36483 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36485 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36486 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36487 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36488 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36489 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36490 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36492 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36493 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36494 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36495 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36496 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36500 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36501 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36502 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36503 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36504 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36505 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36506 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36507 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36508 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36510 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36511 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36514 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36515 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36517 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36519 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36520 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36521 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36522 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36525 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36526 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36527 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36530 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36531 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36532 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36534 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36535 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36537 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36540 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36541 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36542 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36543 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36544 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36545 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36546 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36551 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36552 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36554 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36555 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36556 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36558 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36559 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36560 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36561 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36563 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36565 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36566 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36567 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36568 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36571 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36572 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36573 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36574 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36575 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36576 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36577 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36578 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36579 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36580 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36582 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36583 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36584 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36586 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36587 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36588 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36589 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36591 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36593 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36594 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36595 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36596 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36597 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36598 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36599 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36600 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36601 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36602 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36603 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36605 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36606 { NULL, NULL, 0, NULL }
36607 };
36608
36609
36610 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
36611
36612 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
36613 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
36614 }
36615 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
36616 return (void *)((wxEvent *) ((wxMenuEvent *) x));
36617 }
36618 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
36619 return (void *)((wxEvent *) ((wxCloseEvent *) x));
36620 }
36621 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
36622 return (void *)((wxEvent *) ((wxMouseEvent *) x));
36623 }
36624 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
36625 return (void *)((wxEvent *) ((wxEraseEvent *) x));
36626 }
36627 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
36628 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
36629 }
36630 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
36631 return (void *)((wxEvent *) ((wxTimerEvent *) x));
36632 }
36633 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
36634 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
36635 }
36636 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
36637 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
36638 }
36639 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
36640 return (void *)((wxEvent *) ((wxPyEvent *) x));
36641 }
36642 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
36643 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
36644 }
36645 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
36646 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
36647 }
36648 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
36649 return (void *)((wxEvent *) ((wxIdleEvent *) x));
36650 }
36651 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
36652 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
36653 }
36654 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
36655 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
36656 }
36657 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
36658 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
36659 }
36660 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
36661 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
36662 }
36663 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
36664 return (void *)((wxEvent *) ((wxActivateEvent *) x));
36665 }
36666 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
36667 return (void *)((wxEvent *) ((wxSizeEvent *) x));
36668 }
36669 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
36670 return (void *)((wxEvent *) ((wxMoveEvent *) x));
36671 }
36672 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
36673 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
36674 }
36675 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
36676 return (void *)((wxEvent *) ((wxPaintEvent *) x));
36677 }
36678 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
36679 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
36680 }
36681 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
36682 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
36683 }
36684 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
36685 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
36686 }
36687 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
36688 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
36689 }
36690 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
36691 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36692 }
36693 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
36694 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
36695 }
36696 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
36697 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
36698 }
36699 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
36700 return (void *)((wxEvent *) ((wxFocusEvent *) x));
36701 }
36702 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
36703 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
36704 }
36705 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
36706 return (void *)((wxEvent *) ((wxProcessEvent *) x));
36707 }
36708 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
36709 return (void *)((wxEvent *) ((wxShowEvent *) x));
36710 }
36711 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
36712 return (void *)((wxEvent *) ((wxCommandEvent *) x));
36713 }
36714 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
36715 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
36716 }
36717 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
36718 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
36719 }
36720 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
36721 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
36722 }
36723 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
36724 return (void *)((wxEvent *) ((wxKeyEvent *) x));
36725 }
36726 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
36727 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
36728 }
36729 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
36730 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
36731 }
36732 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
36733 return (void *)((wxConfigBase *) ((wxConfig *) x));
36734 }
36735 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
36736 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36737 }
36738 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
36739 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
36740 }
36741 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
36742 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
36743 }
36744 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
36745 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36746 }
36747 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
36748 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
36749 }
36750 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
36751 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
36752 }
36753 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
36754 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
36755 }
36756 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
36757 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36758 }
36759 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
36760 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36761 }
36762 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
36763 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
36764 }
36765 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
36766 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
36767 }
36768 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
36769 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
36770 }
36771 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
36772 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
36773 }
36774 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
36775 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36776 }
36777 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
36778 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
36779 }
36780 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
36781 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
36782 }
36783 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
36784 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36785 }
36786 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
36787 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36788 }
36789 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
36790 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
36791 }
36792 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
36793 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
36794 }
36795 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
36796 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
36797 }
36798 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
36799 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
36800 }
36801 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
36802 return (void *)((wxEvtHandler *) ((wxWindow *) x));
36803 }
36804 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
36805 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
36806 }
36807 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
36808 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
36809 }
36810 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
36811 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
36812 }
36813 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
36814 return (void *)((wxEvtHandler *) ((wxValidator *) x));
36815 }
36816 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
36817 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
36818 }
36819 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
36820 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
36821 }
36822 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
36823 return (void *)((wxEvtHandler *) ((wxMenu *) x));
36824 }
36825 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
36826 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
36827 }
36828 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
36829 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
36830 }
36831 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
36832 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
36833 }
36834 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
36835 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
36836 }
36837 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
36838 return (void *)((wxObject *) ((wxSizerItem *) x));
36839 }
36840 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
36841 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
36842 }
36843 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
36844 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
36845 }
36846 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
36847 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
36848 }
36849 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
36850 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
36851 }
36852 static void *_p_wxSizerTo_p_wxObject(void *x) {
36853 return (void *)((wxObject *) ((wxSizer *) x));
36854 }
36855 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
36856 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
36857 }
36858 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
36859 return (void *)((wxObject *) ((wxFileHistory *) x));
36860 }
36861 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
36862 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
36863 }
36864 static void *_p_wxEventTo_p_wxObject(void *x) {
36865 return (void *)((wxObject *) ((wxEvent *) x));
36866 }
36867 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
36868 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
36869 }
36870 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
36871 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
36872 }
36873 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
36874 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
36875 }
36876 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
36877 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
36878 }
36879 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
36880 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
36881 }
36882 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
36883 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
36884 }
36885 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
36886 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
36887 }
36888 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
36889 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36890 }
36891 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
36892 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
36893 }
36894 static void *_p_wxControlTo_p_wxObject(void *x) {
36895 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
36896 }
36897 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
36898 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
36899 }
36900 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
36901 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
36902 }
36903 static void *_p_wxFSFileTo_p_wxObject(void *x) {
36904 return (void *)((wxObject *) ((wxFSFile *) x));
36905 }
36906 static void *_p_wxClipboardTo_p_wxObject(void *x) {
36907 return (void *)((wxObject *) ((wxClipboard *) x));
36908 }
36909 static void *_p_wxPySizerTo_p_wxObject(void *x) {
36910 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
36911 }
36912 static void *_p_wxPyEventTo_p_wxObject(void *x) {
36913 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
36914 }
36915 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
36916 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
36917 }
36918 static void *_p_wxShowEventTo_p_wxObject(void *x) {
36919 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
36920 }
36921 static void *_p_wxToolTipTo_p_wxObject(void *x) {
36922 return (void *)((wxObject *) ((wxToolTip *) x));
36923 }
36924 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
36925 return (void *)((wxObject *) ((wxMenuItem *) x));
36926 }
36927 static void *_p_wxDateEventTo_p_wxObject(void *x) {
36928 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
36929 }
36930 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
36931 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
36932 }
36933 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
36934 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
36935 }
36936 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
36937 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
36938 }
36939 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
36940 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
36941 }
36942 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
36943 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
36944 }
36945 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
36946 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
36947 }
36948 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
36949 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
36950 }
36951 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
36952 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
36953 }
36954 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
36955 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
36956 }
36957 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
36958 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
36959 }
36960 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
36961 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
36962 }
36963 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
36964 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
36965 }
36966 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
36967 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
36968 }
36969 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
36970 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
36971 }
36972 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
36973 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
36974 }
36975 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
36976 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
36977 }
36978 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
36979 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
36980 }
36981 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
36982 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
36983 }
36984 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
36985 return (void *)((wxObject *) ((wxImageHandler *) x));
36986 }
36987 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
36988 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
36989 }
36990 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
36991 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
36992 }
36993 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
36994 return (void *)((wxObject *) ((wxEvtHandler *) x));
36995 }
36996 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
36997 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
36998 }
36999 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37000 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37001 }
37002 static void *_p_wxImageTo_p_wxObject(void *x) {
37003 return (void *)((wxObject *) ((wxImage *) x));
37004 }
37005 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37006 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37007 }
37008 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37009 return (void *)((wxObject *) ((wxSystemOptions *) x));
37010 }
37011 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37012 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37013 }
37014 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37015 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37016 }
37017 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37018 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37019 }
37020 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37021 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37022 }
37023 static void *_p_wxWindowTo_p_wxObject(void *x) {
37024 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37025 }
37026 static void *_p_wxMenuTo_p_wxObject(void *x) {
37027 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37028 }
37029 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37030 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37031 }
37032 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37033 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37034 }
37035 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37036 return (void *)((wxObject *) ((wxFileSystem *) x));
37037 }
37038 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37039 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37040 }
37041 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37042 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37043 }
37044 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37045 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37046 }
37047 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37048 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37049 }
37050 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37051 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37052 }
37053 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37054 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37055 }
37056 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37057 return (void *)((wxObject *) ((wxBusyInfo *) x));
37058 }
37059 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37060 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37061 }
37062 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37063 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37064 }
37065 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37066 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37067 }
37068 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37069 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37070 }
37071 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37072 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37073 }
37074 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37075 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37076 }
37077 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37078 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37079 }
37080 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37081 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37082 }
37083 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37084 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37085 }
37086 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37087 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37088 }
37089 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37090 return (void *)((wxLog *) ((wxLogBuffer *) x));
37091 }
37092 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37093 return (void *)((wxLog *) ((wxLogStderr *) x));
37094 }
37095 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37096 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37097 }
37098 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37099 return (void *)((wxLog *) ((wxLogWindow *) x));
37100 }
37101 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37102 return (void *)((wxLog *) ((wxLogChain *) x));
37103 }
37104 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37105 return (void *)((wxLog *) ((wxLogGui *) x));
37106 }
37107 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37108 return (void *)((wxLog *) ((wxPyLog *) x));
37109 }
37110 static void *_p_wxControlTo_p_wxWindow(void *x) {
37111 return (void *)((wxWindow *) ((wxControl *) x));
37112 }
37113 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37114 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37115 }
37116 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37117 return (void *)((wxWindow *) ((wxMenuBar *) x));
37118 }
37119 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37120 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37121 }
37122 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37123 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37124 }
37125 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37126 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};
37127 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37128 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37129 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37130 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37131 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37132 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37133 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37134 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37135 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37136 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37137 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37138 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37139 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37140 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37141 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37142 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37143 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37144 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37145 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37146 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37147 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37148 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37149 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37150 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37151 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37152 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37153 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37154 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37155 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37156 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37157 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37158 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37159 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37160 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37161 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37162 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37163 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37164 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37165 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37166 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37167 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37168 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37169 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37170 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37171 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37172 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37173 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37174 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37175 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37176 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37177 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37178 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37179 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37180 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37181 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37182 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37183 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37184 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37185 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37186 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37187 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37188 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37189 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37190 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37191 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37192 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37193 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37194 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37195 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37196 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37197 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37198 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37199 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37200 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37201 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37202 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37203 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37204 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37205 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37206 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37207 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37208 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37209 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37210 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37211 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37212 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37213 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37214 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37215 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37216 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37217 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37218 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37219 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37220 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37221 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37222 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37223 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37224 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37225 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37226 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37227 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37228 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37229 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37230 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37231 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37232 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37233 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37234 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37235 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37236 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37237 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37238 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37239 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37240 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37241 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37242 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37243 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37244 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37245 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37246 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37247 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37248 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37249 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37250 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37251 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37252 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37253 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37254 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37255 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37256 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37257 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37258 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37259 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37260 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37261 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37262 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37263 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37264 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37265 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37266 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37267 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37268 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37269 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37270 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37271 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37272 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37273 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37274 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37275 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37276 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37277 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37278 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37279 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37280 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37281 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37282 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37283 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37284 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37285 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37286 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37287 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37288 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37289 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37290 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37291 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37292 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37293 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37294
37295 static swig_type_info *swig_type_initial[] = {
37296 &_swigt__p_char,
37297 &_swigt__p_form_ops_t,
37298 &_swigt__p_int,
37299 &_swigt__p_unsigned_char,
37300 &_swigt__p_unsigned_int,
37301 &_swigt__p_unsigned_long,
37302 &_swigt__p_void,
37303 &_swigt__p_wxANIHandler,
37304 &_swigt__p_wxAcceleratorTable,
37305 &_swigt__p_wxActivateEvent,
37306 &_swigt__p_wxArrayString,
37307 &_swigt__p_wxBMPHandler,
37308 &_swigt__p_wxBitmap,
37309 &_swigt__p_wxBitmapDataObject,
37310 &_swigt__p_wxBoxSizer,
37311 &_swigt__p_wxBusyCursor,
37312 &_swigt__p_wxBusyInfo,
37313 &_swigt__p_wxCURHandler,
37314 &_swigt__p_wxCaret,
37315 &_swigt__p_wxChar,
37316 &_swigt__p_wxChildFocusEvent,
37317 &_swigt__p_wxClipboard,
37318 &_swigt__p_wxClipboardLocker,
37319 &_swigt__p_wxCloseEvent,
37320 &_swigt__p_wxColour,
37321 &_swigt__p_wxCommandEvent,
37322 &_swigt__p_wxConfig,
37323 &_swigt__p_wxConfigBase,
37324 &_swigt__p_wxConfigPathChanger,
37325 &_swigt__p_wxContextMenuEvent,
37326 &_swigt__p_wxControl,
37327 &_swigt__p_wxControlWithItems,
37328 &_swigt__p_wxCursor,
37329 &_swigt__p_wxCustomDataObject,
37330 &_swigt__p_wxDC,
37331 &_swigt__p_wxDataFormat,
37332 &_swigt__p_wxDataObject,
37333 &_swigt__p_wxDataObjectComposite,
37334 &_swigt__p_wxDataObjectSimple,
37335 &_swigt__p_wxDateEvent,
37336 &_swigt__p_wxDateSpan,
37337 &_swigt__p_wxDateTime,
37338 &_swigt__p_wxDateTime__TimeZone,
37339 &_swigt__p_wxDisplay,
37340 &_swigt__p_wxDisplayChangedEvent,
37341 &_swigt__p_wxDropFilesEvent,
37342 &_swigt__p_wxDuplexMode,
37343 &_swigt__p_wxEraseEvent,
37344 &_swigt__p_wxEvent,
37345 &_swigt__p_wxEvtHandler,
37346 &_swigt__p_wxFSFile,
37347 &_swigt__p_wxFileConfig,
37348 &_swigt__p_wxFileDataObject,
37349 &_swigt__p_wxFileHistory,
37350 &_swigt__p_wxFileSystem,
37351 &_swigt__p_wxFileType,
37352 &_swigt__p_wxFileTypeInfo,
37353 &_swigt__p_wxFlexGridSizer,
37354 &_swigt__p_wxFocusEvent,
37355 &_swigt__p_wxFont,
37356 &_swigt__p_wxFrame,
37357 &_swigt__p_wxGBSizerItem,
37358 &_swigt__p_wxGIFHandler,
37359 &_swigt__p_wxGridBagSizer,
37360 &_swigt__p_wxGridSizer,
37361 &_swigt__p_wxICOHandler,
37362 &_swigt__p_wxIcon,
37363 &_swigt__p_wxIconizeEvent,
37364 &_swigt__p_wxIdleEvent,
37365 &_swigt__p_wxImage,
37366 &_swigt__p_wxImageHandler,
37367 &_swigt__p_wxIndividualLayoutConstraint,
37368 &_swigt__p_wxInitDialogEvent,
37369 &_swigt__p_wxJPEGHandler,
37370 &_swigt__p_wxJoystick,
37371 &_swigt__p_wxJoystickEvent,
37372 &_swigt__p_wxKeyEvent,
37373 &_swigt__p_wxKillError,
37374 &_swigt__p_wxLayoutConstraints,
37375 &_swigt__p_wxLog,
37376 &_swigt__p_wxLogBuffer,
37377 &_swigt__p_wxLogChain,
37378 &_swigt__p_wxLogGui,
37379 &_swigt__p_wxLogNull,
37380 &_swigt__p_wxLogStderr,
37381 &_swigt__p_wxLogTextCtrl,
37382 &_swigt__p_wxLogWindow,
37383 &_swigt__p_wxMaximizeEvent,
37384 &_swigt__p_wxMemorySize,
37385 &_swigt__p_wxMenu,
37386 &_swigt__p_wxMenuBar,
37387 &_swigt__p_wxMenuEvent,
37388 &_swigt__p_wxMenuItem,
37389 &_swigt__p_wxMetafileDataObject,
37390 &_swigt__p_wxMimeTypesManager,
37391 &_swigt__p_wxMouseCaptureChangedEvent,
37392 &_swigt__p_wxMouseEvent,
37393 &_swigt__p_wxMouseState,
37394 &_swigt__p_wxMoveEvent,
37395 &_swigt__p_wxMutexGuiLocker,
37396 &_swigt__p_wxNavigationKeyEvent,
37397 &_swigt__p_wxNcPaintEvent,
37398 &_swigt__p_wxNotifyEvent,
37399 &_swigt__p_wxObject,
37400 &_swigt__p_wxOutputStream,
37401 &_swigt__p_wxPCXHandler,
37402 &_swigt__p_wxPNGHandler,
37403 &_swigt__p_wxPNMHandler,
37404 &_swigt__p_wxPaintEvent,
37405 &_swigt__p_wxPaletteChangedEvent,
37406 &_swigt__p_wxPaperSize,
37407 &_swigt__p_wxPoint,
37408 &_swigt__p_wxProcessEvent,
37409 &_swigt__p_wxPyApp,
37410 &_swigt__p_wxPyArtProvider,
37411 &_swigt__p_wxPyBitmapDataObject,
37412 &_swigt__p_wxPyCommandEvent,
37413 &_swigt__p_wxPyDataObjectSimple,
37414 &_swigt__p_wxPyDropSource,
37415 &_swigt__p_wxPyDropTarget,
37416 &_swigt__p_wxPyEvent,
37417 &_swigt__p_wxPyFileDropTarget,
37418 &_swigt__p_wxPyImageHandler,
37419 &_swigt__p_wxPyLog,
37420 &_swigt__p_wxPyProcess,
37421 &_swigt__p_wxPySizer,
37422 &_swigt__p_wxPyTextDataObject,
37423 &_swigt__p_wxPyTextDropTarget,
37424 &_swigt__p_wxPyTimer,
37425 &_swigt__p_wxPyTipProvider,
37426 &_swigt__p_wxPyValidator,
37427 &_swigt__p_wxQueryNewPaletteEvent,
37428 &_swigt__p_wxRect,
37429 &_swigt__p_wxScrollEvent,
37430 &_swigt__p_wxScrollWinEvent,
37431 &_swigt__p_wxSetCursorEvent,
37432 &_swigt__p_wxShowEvent,
37433 &_swigt__p_wxSingleInstanceChecker,
37434 &_swigt__p_wxSize,
37435 &_swigt__p_wxSizeEvent,
37436 &_swigt__p_wxSizer,
37437 &_swigt__p_wxSizerItem,
37438 &_swigt__p_wxSound,
37439 &_swigt__p_wxStandardPaths,
37440 &_swigt__p_wxStaticBoxSizer,
37441 &_swigt__p_wxStdDialogButtonSizer,
37442 &_swigt__p_wxStopWatch,
37443 &_swigt__p_wxString,
37444 &_swigt__p_wxSysColourChangedEvent,
37445 &_swigt__p_wxSystemOptions,
37446 &_swigt__p_wxSystemSettings,
37447 &_swigt__p_wxTIFFHandler,
37448 &_swigt__p_wxTextCtrl,
37449 &_swigt__p_wxTextDataObject,
37450 &_swigt__p_wxTimeSpan,
37451 &_swigt__p_wxTimer,
37452 &_swigt__p_wxTimerEvent,
37453 &_swigt__p_wxTimerRunner,
37454 &_swigt__p_wxTipProvider,
37455 &_swigt__p_wxToolTip,
37456 &_swigt__p_wxURLDataObject,
37457 &_swigt__p_wxUpdateUIEvent,
37458 &_swigt__p_wxValidator,
37459 &_swigt__p_wxVideoMode,
37460 &_swigt__p_wxWindow,
37461 &_swigt__p_wxWindowCreateEvent,
37462 &_swigt__p_wxWindowDestroyEvent,
37463 &_swigt__p_wxWindowDisabler,
37464 &_swigt__p_wxXPMHandler,
37465 };
37466
37467 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37468 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37469 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37470 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37471 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37472 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37473 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37474 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37475 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37476 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}};
37477 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37478 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37479 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37480 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37481 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37482 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37483 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37484 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37485 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}};
37486 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37487 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37488 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37489 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37490 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37491 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}};
37492 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37493 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}};
37494 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37495 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37496 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37497 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37498 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37499 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37500 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37501 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37502 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37503 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37504 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37505 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37506 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37507 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37508 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37509 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37510 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37511 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37512 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37513 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37514 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37515 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37516 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37517 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37518 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37519 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37520 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37521 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37522 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37523 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37524 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37525 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37526 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37527 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37528 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37529 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37530 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37531 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37532 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37533 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37534 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37535 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_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_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}};
37536 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37537 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37538 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37539 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37540 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37541 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37542 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}};
37543 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37544 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37545 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37546 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37547 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37548 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37549 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37550 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37551 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37552 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37553 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37554 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}};
37555 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37556 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37557 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37558 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37559 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37560 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37561 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37562 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37563 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37564 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37565 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37566 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37567 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37568 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37569 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37570 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37571 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37572 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37573 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37574 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37575 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37576 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37577 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37578 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37579 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37580 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37581 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
37582 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37583 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37584 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37585 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37586 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37587 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
37588 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
37589 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
37590 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
37591 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
37592 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
37593 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
37594 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
37595 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
37596 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
37597 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
37598 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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_wxICOHandler, _p_wxICOHandlerTo_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_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}};
37599 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
37600 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
37601 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
37602 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
37603 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
37604 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
37605 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
37606 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
37607 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}};
37608 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37609 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
37610 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
37611 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
37612 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37613 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
37614 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
37615 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
37616 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
37617 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
37618 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
37619 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
37620 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
37621 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
37622 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
37623 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
37624 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37625 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}};
37626 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
37627 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
37628 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
37629 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
37630 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}};
37631 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
37632 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
37633 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
37634 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}};
37635 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
37636
37637 static swig_cast_info *swig_cast_initial[] = {
37638 _swigc__p_char,
37639 _swigc__p_form_ops_t,
37640 _swigc__p_int,
37641 _swigc__p_unsigned_char,
37642 _swigc__p_unsigned_int,
37643 _swigc__p_unsigned_long,
37644 _swigc__p_void,
37645 _swigc__p_wxANIHandler,
37646 _swigc__p_wxAcceleratorTable,
37647 _swigc__p_wxActivateEvent,
37648 _swigc__p_wxArrayString,
37649 _swigc__p_wxBMPHandler,
37650 _swigc__p_wxBitmap,
37651 _swigc__p_wxBitmapDataObject,
37652 _swigc__p_wxBoxSizer,
37653 _swigc__p_wxBusyCursor,
37654 _swigc__p_wxBusyInfo,
37655 _swigc__p_wxCURHandler,
37656 _swigc__p_wxCaret,
37657 _swigc__p_wxChar,
37658 _swigc__p_wxChildFocusEvent,
37659 _swigc__p_wxClipboard,
37660 _swigc__p_wxClipboardLocker,
37661 _swigc__p_wxCloseEvent,
37662 _swigc__p_wxColour,
37663 _swigc__p_wxCommandEvent,
37664 _swigc__p_wxConfig,
37665 _swigc__p_wxConfigBase,
37666 _swigc__p_wxConfigPathChanger,
37667 _swigc__p_wxContextMenuEvent,
37668 _swigc__p_wxControl,
37669 _swigc__p_wxControlWithItems,
37670 _swigc__p_wxCursor,
37671 _swigc__p_wxCustomDataObject,
37672 _swigc__p_wxDC,
37673 _swigc__p_wxDataFormat,
37674 _swigc__p_wxDataObject,
37675 _swigc__p_wxDataObjectComposite,
37676 _swigc__p_wxDataObjectSimple,
37677 _swigc__p_wxDateEvent,
37678 _swigc__p_wxDateSpan,
37679 _swigc__p_wxDateTime,
37680 _swigc__p_wxDateTime__TimeZone,
37681 _swigc__p_wxDisplay,
37682 _swigc__p_wxDisplayChangedEvent,
37683 _swigc__p_wxDropFilesEvent,
37684 _swigc__p_wxDuplexMode,
37685 _swigc__p_wxEraseEvent,
37686 _swigc__p_wxEvent,
37687 _swigc__p_wxEvtHandler,
37688 _swigc__p_wxFSFile,
37689 _swigc__p_wxFileConfig,
37690 _swigc__p_wxFileDataObject,
37691 _swigc__p_wxFileHistory,
37692 _swigc__p_wxFileSystem,
37693 _swigc__p_wxFileType,
37694 _swigc__p_wxFileTypeInfo,
37695 _swigc__p_wxFlexGridSizer,
37696 _swigc__p_wxFocusEvent,
37697 _swigc__p_wxFont,
37698 _swigc__p_wxFrame,
37699 _swigc__p_wxGBSizerItem,
37700 _swigc__p_wxGIFHandler,
37701 _swigc__p_wxGridBagSizer,
37702 _swigc__p_wxGridSizer,
37703 _swigc__p_wxICOHandler,
37704 _swigc__p_wxIcon,
37705 _swigc__p_wxIconizeEvent,
37706 _swigc__p_wxIdleEvent,
37707 _swigc__p_wxImage,
37708 _swigc__p_wxImageHandler,
37709 _swigc__p_wxIndividualLayoutConstraint,
37710 _swigc__p_wxInitDialogEvent,
37711 _swigc__p_wxJPEGHandler,
37712 _swigc__p_wxJoystick,
37713 _swigc__p_wxJoystickEvent,
37714 _swigc__p_wxKeyEvent,
37715 _swigc__p_wxKillError,
37716 _swigc__p_wxLayoutConstraints,
37717 _swigc__p_wxLog,
37718 _swigc__p_wxLogBuffer,
37719 _swigc__p_wxLogChain,
37720 _swigc__p_wxLogGui,
37721 _swigc__p_wxLogNull,
37722 _swigc__p_wxLogStderr,
37723 _swigc__p_wxLogTextCtrl,
37724 _swigc__p_wxLogWindow,
37725 _swigc__p_wxMaximizeEvent,
37726 _swigc__p_wxMemorySize,
37727 _swigc__p_wxMenu,
37728 _swigc__p_wxMenuBar,
37729 _swigc__p_wxMenuEvent,
37730 _swigc__p_wxMenuItem,
37731 _swigc__p_wxMetafileDataObject,
37732 _swigc__p_wxMimeTypesManager,
37733 _swigc__p_wxMouseCaptureChangedEvent,
37734 _swigc__p_wxMouseEvent,
37735 _swigc__p_wxMouseState,
37736 _swigc__p_wxMoveEvent,
37737 _swigc__p_wxMutexGuiLocker,
37738 _swigc__p_wxNavigationKeyEvent,
37739 _swigc__p_wxNcPaintEvent,
37740 _swigc__p_wxNotifyEvent,
37741 _swigc__p_wxObject,
37742 _swigc__p_wxOutputStream,
37743 _swigc__p_wxPCXHandler,
37744 _swigc__p_wxPNGHandler,
37745 _swigc__p_wxPNMHandler,
37746 _swigc__p_wxPaintEvent,
37747 _swigc__p_wxPaletteChangedEvent,
37748 _swigc__p_wxPaperSize,
37749 _swigc__p_wxPoint,
37750 _swigc__p_wxProcessEvent,
37751 _swigc__p_wxPyApp,
37752 _swigc__p_wxPyArtProvider,
37753 _swigc__p_wxPyBitmapDataObject,
37754 _swigc__p_wxPyCommandEvent,
37755 _swigc__p_wxPyDataObjectSimple,
37756 _swigc__p_wxPyDropSource,
37757 _swigc__p_wxPyDropTarget,
37758 _swigc__p_wxPyEvent,
37759 _swigc__p_wxPyFileDropTarget,
37760 _swigc__p_wxPyImageHandler,
37761 _swigc__p_wxPyLog,
37762 _swigc__p_wxPyProcess,
37763 _swigc__p_wxPySizer,
37764 _swigc__p_wxPyTextDataObject,
37765 _swigc__p_wxPyTextDropTarget,
37766 _swigc__p_wxPyTimer,
37767 _swigc__p_wxPyTipProvider,
37768 _swigc__p_wxPyValidator,
37769 _swigc__p_wxQueryNewPaletteEvent,
37770 _swigc__p_wxRect,
37771 _swigc__p_wxScrollEvent,
37772 _swigc__p_wxScrollWinEvent,
37773 _swigc__p_wxSetCursorEvent,
37774 _swigc__p_wxShowEvent,
37775 _swigc__p_wxSingleInstanceChecker,
37776 _swigc__p_wxSize,
37777 _swigc__p_wxSizeEvent,
37778 _swigc__p_wxSizer,
37779 _swigc__p_wxSizerItem,
37780 _swigc__p_wxSound,
37781 _swigc__p_wxStandardPaths,
37782 _swigc__p_wxStaticBoxSizer,
37783 _swigc__p_wxStdDialogButtonSizer,
37784 _swigc__p_wxStopWatch,
37785 _swigc__p_wxString,
37786 _swigc__p_wxSysColourChangedEvent,
37787 _swigc__p_wxSystemOptions,
37788 _swigc__p_wxSystemSettings,
37789 _swigc__p_wxTIFFHandler,
37790 _swigc__p_wxTextCtrl,
37791 _swigc__p_wxTextDataObject,
37792 _swigc__p_wxTimeSpan,
37793 _swigc__p_wxTimer,
37794 _swigc__p_wxTimerEvent,
37795 _swigc__p_wxTimerRunner,
37796 _swigc__p_wxTipProvider,
37797 _swigc__p_wxToolTip,
37798 _swigc__p_wxURLDataObject,
37799 _swigc__p_wxUpdateUIEvent,
37800 _swigc__p_wxValidator,
37801 _swigc__p_wxVideoMode,
37802 _swigc__p_wxWindow,
37803 _swigc__p_wxWindowCreateEvent,
37804 _swigc__p_wxWindowDestroyEvent,
37805 _swigc__p_wxWindowDisabler,
37806 _swigc__p_wxXPMHandler,
37807 };
37808
37809
37810 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
37811
37812 static swig_const_info swig_const_table[] = {
37813 {0, 0, 0, 0.0, 0, 0}};
37814
37815 #ifdef __cplusplus
37816 }
37817 #endif
37818 /* -----------------------------------------------------------------------------
37819 * Type initialization:
37820 * This problem is tough by the requirement that no dynamic
37821 * memory is used. Also, since swig_type_info structures store pointers to
37822 * swig_cast_info structures and swig_cast_info structures store pointers back
37823 * to swig_type_info structures, we need some lookup code at initialization.
37824 * The idea is that swig generates all the structures that are needed.
37825 * The runtime then collects these partially filled structures.
37826 * The SWIG_InitializeModule function takes these initial arrays out of
37827 * swig_module, and does all the lookup, filling in the swig_module.types
37828 * array with the correct data and linking the correct swig_cast_info
37829 * structures together.
37830 *
37831 * The generated swig_type_info structures are assigned staticly to an initial
37832 * array. We just loop though that array, and handle each type individually.
37833 * First we lookup if this type has been already loaded, and if so, use the
37834 * loaded structure instead of the generated one. Then we have to fill in the
37835 * cast linked list. The cast data is initially stored in something like a
37836 * two-dimensional array. Each row corresponds to a type (there are the same
37837 * number of rows as there are in the swig_type_initial array). Each entry in
37838 * a column is one of the swig_cast_info structures for that type.
37839 * The cast_initial array is actually an array of arrays, because each row has
37840 * a variable number of columns. So to actually build the cast linked list,
37841 * we find the array of casts associated with the type, and loop through it
37842 * adding the casts to the list. The one last trick we need to do is making
37843 * sure the type pointer in the swig_cast_info struct is correct.
37844 *
37845 * First off, we lookup the cast->type name to see if it is already loaded.
37846 * There are three cases to handle:
37847 * 1) If the cast->type has already been loaded AND the type we are adding
37848 * casting info to has not been loaded (it is in this module), THEN we
37849 * replace the cast->type pointer with the type pointer that has already
37850 * been loaded.
37851 * 2) If BOTH types (the one we are adding casting info to, and the
37852 * cast->type) are loaded, THEN the cast info has already been loaded by
37853 * the previous module so we just ignore it.
37854 * 3) Finally, if cast->type has not already been loaded, then we add that
37855 * swig_cast_info to the linked list (because the cast->type) pointer will
37856 * be correct.
37857 * ----------------------------------------------------------------------------- */
37858
37859 #ifdef __cplusplus
37860 extern "C" {
37861 #if 0
37862 } /* c-mode */
37863 #endif
37864 #endif
37865
37866 #if 0
37867 #define SWIGRUNTIME_DEBUG
37868 #endif
37869
37870 SWIGRUNTIME void
37871 SWIG_InitializeModule(void *clientdata) {
37872 size_t i;
37873 swig_module_info *module_head;
37874 static int init_run = 0;
37875
37876 clientdata = clientdata;
37877
37878 if (init_run) return;
37879 init_run = 1;
37880
37881 /* Initialize the swig_module */
37882 swig_module.type_initial = swig_type_initial;
37883 swig_module.cast_initial = swig_cast_initial;
37884
37885 /* Try and load any already created modules */
37886 module_head = SWIG_GetModule(clientdata);
37887 if (module_head) {
37888 swig_module.next = module_head->next;
37889 module_head->next = &swig_module;
37890 } else {
37891 /* This is the first module loaded */
37892 swig_module.next = &swig_module;
37893 SWIG_SetModule(clientdata, &swig_module);
37894 }
37895
37896 /* Now work on filling in swig_module.types */
37897 #ifdef SWIGRUNTIME_DEBUG
37898 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
37899 #endif
37900 for (i = 0; i < swig_module.size; ++i) {
37901 swig_type_info *type = 0;
37902 swig_type_info *ret;
37903 swig_cast_info *cast;
37904
37905 #ifdef SWIGRUNTIME_DEBUG
37906 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
37907 #endif
37908
37909 /* if there is another module already loaded */
37910 if (swig_module.next != &swig_module) {
37911 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
37912 }
37913 if (type) {
37914 /* Overwrite clientdata field */
37915 #ifdef SWIGRUNTIME_DEBUG
37916 printf("SWIG_InitializeModule: found type %s\n", type->name);
37917 #endif
37918 if (swig_module.type_initial[i]->clientdata) {
37919 type->clientdata = swig_module.type_initial[i]->clientdata;
37920 #ifdef SWIGRUNTIME_DEBUG
37921 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
37922 #endif
37923 }
37924 } else {
37925 type = swig_module.type_initial[i];
37926 }
37927
37928 /* Insert casting types */
37929 cast = swig_module.cast_initial[i];
37930 while (cast->type) {
37931 /* Don't need to add information already in the list */
37932 ret = 0;
37933 #ifdef SWIGRUNTIME_DEBUG
37934 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
37935 #endif
37936 if (swig_module.next != &swig_module) {
37937 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
37938 #ifdef SWIGRUNTIME_DEBUG
37939 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
37940 #endif
37941 }
37942 if (ret) {
37943 if (type == swig_module.type_initial[i]) {
37944 #ifdef SWIGRUNTIME_DEBUG
37945 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
37946 #endif
37947 cast->type = ret;
37948 ret = 0;
37949 } else {
37950 /* Check for casting already in the list */
37951 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
37952 #ifdef SWIGRUNTIME_DEBUG
37953 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
37954 #endif
37955 if (!ocast) ret = 0;
37956 }
37957 }
37958
37959 if (!ret) {
37960 #ifdef SWIGRUNTIME_DEBUG
37961 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
37962 #endif
37963 if (type->cast) {
37964 type->cast->prev = cast;
37965 cast->next = type->cast;
37966 }
37967 type->cast = cast;
37968 }
37969 cast++;
37970 }
37971 /* Set entry in modules->types array equal to the type */
37972 swig_module.types[i] = type;
37973 }
37974 swig_module.types[i] = 0;
37975
37976 #ifdef SWIGRUNTIME_DEBUG
37977 printf("**** SWIG_InitializeModule: Cast List ******\n");
37978 for (i = 0; i < swig_module.size; ++i) {
37979 int j = 0;
37980 swig_cast_info *cast = swig_module.cast_initial[i];
37981 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
37982 while (cast->type) {
37983 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
37984 cast++;
37985 ++j;
37986 }
37987 printf("---- Total casts: %d\n",j);
37988 }
37989 printf("**** SWIG_InitializeModule: Cast List ******\n");
37990 #endif
37991 }
37992
37993 /* This function will propagate the clientdata field of type to
37994 * any new swig_type_info structures that have been added into the list
37995 * of equivalent types. It is like calling
37996 * SWIG_TypeClientData(type, clientdata) a second time.
37997 */
37998 SWIGRUNTIME void
37999 SWIG_PropagateClientData(void) {
38000 size_t i;
38001 swig_cast_info *equiv;
38002 static int init_run = 0;
38003
38004 if (init_run) return;
38005 init_run = 1;
38006
38007 for (i = 0; i < swig_module.size; i++) {
38008 if (swig_module.types[i]->clientdata) {
38009 equiv = swig_module.types[i]->cast;
38010 while (equiv) {
38011 if (!equiv->converter) {
38012 if (equiv->type && !equiv->type->clientdata)
38013 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38014 }
38015 equiv = equiv->next;
38016 }
38017 }
38018 }
38019 }
38020
38021 #ifdef __cplusplus
38022 #if 0
38023 {
38024 /* c-mode */
38025 #endif
38026 }
38027 #endif
38028
38029
38030
38031 #ifdef __cplusplus
38032 extern "C" {
38033 #endif
38034
38035 /* Python-specific SWIG API */
38036 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38037 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38038 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38039
38040 /* -----------------------------------------------------------------------------
38041 * global variable support code.
38042 * ----------------------------------------------------------------------------- */
38043
38044 typedef struct swig_globalvar {
38045 char *name; /* Name of global variable */
38046 PyObject *(*get_attr)(void); /* Return the current value */
38047 int (*set_attr)(PyObject *); /* Set the value */
38048 struct swig_globalvar *next;
38049 } swig_globalvar;
38050
38051 typedef struct swig_varlinkobject {
38052 PyObject_HEAD
38053 swig_globalvar *vars;
38054 } swig_varlinkobject;
38055
38056 SWIGINTERN PyObject *
38057 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38058 return PyString_FromString("<Swig global variables>");
38059 }
38060
38061 SWIGINTERN PyObject *
38062 swig_varlink_str(swig_varlinkobject *v) {
38063 PyObject *str = PyString_FromString("(");
38064 swig_globalvar *var;
38065 for (var = v->vars; var; var=var->next) {
38066 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38067 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38068 }
38069 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38070 return str;
38071 }
38072
38073 SWIGINTERN int
38074 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38075 PyObject *str = swig_varlink_str(v);
38076 fprintf(fp,"Swig global variables ");
38077 fprintf(fp,"%s\n", PyString_AsString(str));
38078 Py_DECREF(str);
38079 return 0;
38080 }
38081
38082 SWIGINTERN void
38083 swig_varlink_dealloc(swig_varlinkobject *v) {
38084 swig_globalvar *var = v->vars;
38085 while (var) {
38086 swig_globalvar *n = var->next;
38087 free(var->name);
38088 free(var);
38089 var = n;
38090 }
38091 }
38092
38093 SWIGINTERN PyObject *
38094 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38095 PyObject *res = NULL;
38096 swig_globalvar *var = v->vars;
38097 while (var) {
38098 if (strcmp(var->name,n) == 0) {
38099 res = (*var->get_attr)();
38100 break;
38101 }
38102 var = var->next;
38103 }
38104 if (res == NULL && !PyErr_Occurred()) {
38105 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38106 }
38107 return res;
38108 }
38109
38110 SWIGINTERN int
38111 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38112 int res = 1;
38113 swig_globalvar *var = v->vars;
38114 while (var) {
38115 if (strcmp(var->name,n) == 0) {
38116 res = (*var->set_attr)(p);
38117 break;
38118 }
38119 var = var->next;
38120 }
38121 if (res == 1 && !PyErr_Occurred()) {
38122 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38123 }
38124 return res;
38125 }
38126
38127 SWIGINTERN PyTypeObject*
38128 swig_varlink_type(void) {
38129 static char varlink__doc__[] = "Swig var link object";
38130 static PyTypeObject varlink_type;
38131 static int type_init = 0;
38132 if (!type_init) {
38133 const PyTypeObject tmp
38134 = {
38135 PyObject_HEAD_INIT(NULL)
38136 0, /* Number of items in variable part (ob_size) */
38137 (char *)"swigvarlink", /* Type name (tp_name) */
38138 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38139 0, /* Itemsize (tp_itemsize) */
38140 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38141 (printfunc) swig_varlink_print, /* Print (tp_print) */
38142 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38143 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38144 0, /* tp_compare */
38145 (reprfunc) swig_varlink_repr, /* tp_repr */
38146 0, /* tp_as_number */
38147 0, /* tp_as_sequence */
38148 0, /* tp_as_mapping */
38149 0, /* tp_hash */
38150 0, /* tp_call */
38151 (reprfunc)swig_varlink_str, /* tp_str */
38152 0, /* tp_getattro */
38153 0, /* tp_setattro */
38154 0, /* tp_as_buffer */
38155 0, /* tp_flags */
38156 varlink__doc__, /* tp_doc */
38157 0, /* tp_traverse */
38158 0, /* tp_clear */
38159 0, /* tp_richcompare */
38160 0, /* tp_weaklistoffset */
38161 #if PY_VERSION_HEX >= 0x02020000
38162 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38163 #endif
38164 #if PY_VERSION_HEX >= 0x02030000
38165 0, /* tp_del */
38166 #endif
38167 #ifdef COUNT_ALLOCS
38168 0,0,0,0 /* tp_alloc -> tp_next */
38169 #endif
38170 };
38171 varlink_type = tmp;
38172 varlink_type.ob_type = &PyType_Type;
38173 type_init = 1;
38174 }
38175 return &varlink_type;
38176 }
38177
38178 /* Create a variable linking object for use later */
38179 SWIGINTERN PyObject *
38180 SWIG_Python_newvarlink(void) {
38181 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38182 if (result) {
38183 result->vars = 0;
38184 }
38185 return ((PyObject*) result);
38186 }
38187
38188 SWIGINTERN void
38189 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38190 swig_varlinkobject *v = (swig_varlinkobject *) p;
38191 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38192 if (gv) {
38193 size_t size = strlen(name)+1;
38194 gv->name = (char *)malloc(size);
38195 if (gv->name) {
38196 strncpy(gv->name,name,size);
38197 gv->get_attr = get_attr;
38198 gv->set_attr = set_attr;
38199 gv->next = v->vars;
38200 }
38201 }
38202 v->vars = gv;
38203 }
38204
38205 SWIGINTERN PyObject *
38206 SWIG_globals() {
38207 static PyObject *_SWIG_globals = 0;
38208 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38209 return _SWIG_globals;
38210 }
38211
38212 /* -----------------------------------------------------------------------------
38213 * constants/methods manipulation
38214 * ----------------------------------------------------------------------------- */
38215
38216 /* Install Constants */
38217 SWIGINTERN void
38218 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38219 PyObject *obj = 0;
38220 size_t i;
38221 for (i = 0; constants[i].type; ++i) {
38222 switch(constants[i].type) {
38223 case SWIG_PY_POINTER:
38224 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38225 break;
38226 case SWIG_PY_BINARY:
38227 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38228 break;
38229 default:
38230 obj = 0;
38231 break;
38232 }
38233 if (obj) {
38234 PyDict_SetItemString(d, constants[i].name, obj);
38235 Py_DECREF(obj);
38236 }
38237 }
38238 }
38239
38240 /* -----------------------------------------------------------------------------*/
38241 /* Fix SwigMethods to carry the callback ptrs when needed */
38242 /* -----------------------------------------------------------------------------*/
38243
38244 SWIGINTERN void
38245 SWIG_Python_FixMethods(PyMethodDef *methods,
38246 swig_const_info *const_table,
38247 swig_type_info **types,
38248 swig_type_info **types_initial) {
38249 size_t i;
38250 for (i = 0; methods[i].ml_name; ++i) {
38251 char *c = methods[i].ml_doc;
38252 if (c && (c = strstr(c, "swig_ptr: "))) {
38253 int j;
38254 swig_const_info *ci = 0;
38255 char *name = c + 10;
38256 for (j = 0; const_table[j].type; ++j) {
38257 if (strncmp(const_table[j].name, name,
38258 strlen(const_table[j].name)) == 0) {
38259 ci = &(const_table[j]);
38260 break;
38261 }
38262 }
38263 if (ci) {
38264 size_t shift = (ci->ptype) - types;
38265 swig_type_info *ty = types_initial[shift];
38266 size_t ldoc = (c - methods[i].ml_doc);
38267 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38268 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38269 if (ndoc) {
38270 char *buff = ndoc;
38271 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38272 if (ptr) {
38273 strncpy(buff, methods[i].ml_doc, ldoc);
38274 buff += ldoc;
38275 strncpy(buff, "swig_ptr: ", 10);
38276 buff += 10;
38277 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38278 methods[i].ml_doc = ndoc;
38279 }
38280 }
38281 }
38282 }
38283 }
38284 }
38285
38286 #ifdef __cplusplus
38287 }
38288 #endif
38289
38290 /* -----------------------------------------------------------------------------*
38291 * Partial Init method
38292 * -----------------------------------------------------------------------------*/
38293
38294 #ifdef __cplusplus
38295 extern "C"
38296 #endif
38297 SWIGEXPORT void SWIG_init(void) {
38298 PyObject *m, *d;
38299
38300 /* Fix SwigMethods to carry the callback ptrs when needed */
38301 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38302
38303 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38304 d = PyModule_GetDict(m);
38305
38306 SWIG_InitializeModule(0);
38307 SWIG_InstallConstants(d,swig_const_table);
38308
38309
38310 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38311 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38312 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38313 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38314 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38315 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38316 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38317 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38318 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38319 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38320 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38321 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38322 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38323 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38324 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38325 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38326 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38327 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38328 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38329 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38330 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38331 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38332 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38333 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38334 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38335 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38336 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38337 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38338 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38339 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38340 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38341 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38342 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38343 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38344 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38345 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38346 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38347 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38348 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38349 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38350 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38351 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38352 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38353 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38354 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38355 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38356 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38357 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38358 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38359 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38360 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38361 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38362 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38363 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38364 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38365 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38366 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38367 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38368 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38369 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38370 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38371 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38372 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38373 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38374 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38375 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38376 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38377 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38378 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38379 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38380 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38381 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38382 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38383 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38384 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38385 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38386 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38387 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38388 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38389 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38390 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38391 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38392 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38393 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38394 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38395 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38396 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38397 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38398 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38399 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38400 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38401 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38402 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38403 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38404 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38405 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38406 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38407 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38408 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38409 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38410 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38411 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38412
38413 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38414
38415 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38416 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38417 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38418 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38419 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38420 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38421 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38422 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38423 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38424 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38425 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38426 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38427 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38428 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38429 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38430 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38431 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38432 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38433 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38434 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38435 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38436 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38437 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38438 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38439 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38440 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38441 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38442 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38443 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38444 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38445 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38446 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38447 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38448 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38449 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38450 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38451 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38452 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38453 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38454 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38455 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38456 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38457 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38458 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38459 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38460 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38461 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38462 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38463 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38464 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38465 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38466 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38467 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38468
38469 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38470
38471 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38472 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38473 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38474 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38475 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38476 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38477 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38478 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38479 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38480 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38481 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38482 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38483 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38484 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38485 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38486 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38487 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38488 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38489 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38490 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38491 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38492 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38493 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38494 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38495 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38496 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38497 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38498 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38499 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38500 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38501 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38502 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38503 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38504 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38505 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38506 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38507 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38508 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38509 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38510 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38511 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38512 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38513 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38514 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38515 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38516 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38517 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38518 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38519 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38520 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38521 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38522 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38523 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38524 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38525 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38526 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38527 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38528 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38529 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38530 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38531 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38532 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38533 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38534 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38535 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38536 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38537 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38538 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38539 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38540 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38541 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38542 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38543 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38544 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38545 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38546 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38547
38548 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38549
38550 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38551 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38552 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38553 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38554 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38555 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38556 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38557 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38558 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38559 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38560 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38561 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38562 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38563 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38564 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38565 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38566 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38567 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38568 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38569 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38570 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38571 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38572 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38573 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38574 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38575 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38576 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38577 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38578 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38579 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38580 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38581 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38582 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38583 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
38584 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
38585 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
38586 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
38587 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
38588 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
38589 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
38590 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
38591 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
38592 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
38593 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
38594 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
38595 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
38596 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
38597 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
38598 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
38599 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
38600 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
38601 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
38602 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
38603 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
38604 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
38605 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
38606 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
38607 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
38608 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
38609 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
38610 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
38611 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
38612 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
38613 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
38614 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
38615 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
38616 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
38617 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
38618 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
38619 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
38620 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
38621 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
38622 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
38623 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
38624 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
38625 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
38626 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
38627 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
38628 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
38629 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
38630 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
38631 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
38632 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
38633 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
38634 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
38635 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
38636 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
38637 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
38638 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
38639 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
38640 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
38641 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
38642 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
38643 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
38644 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
38645 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
38646 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
38647 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
38648 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
38649 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
38650 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
38651 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
38652 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
38653 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
38654 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
38655 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
38656 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
38657 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
38658 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
38659 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
38660 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
38661 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
38662 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
38663 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
38664 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
38665 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
38666 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
38667 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
38668 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
38669 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
38670 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
38671 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
38672 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
38673 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
38674 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
38675 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
38676 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
38677 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
38678 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
38679 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
38680 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
38681 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
38682 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
38683 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
38684 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
38685 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
38686 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
38687 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
38688 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
38689 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
38690 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
38691 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
38692 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
38693 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
38694 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
38695 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
38696 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
38697 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
38698 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
38699 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
38700 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
38701 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
38702 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
38703 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
38704 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
38705 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
38706 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
38707 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
38708 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
38709 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
38710 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
38711 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
38712 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
38713 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
38714 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
38715 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
38716 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
38717 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
38718 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
38719 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
38720 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
38721 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
38722 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
38723 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
38724 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
38725 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
38726 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
38727 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
38728 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
38729 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
38730 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
38731 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
38732 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
38733 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
38734 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
38735 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
38736 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
38737 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
38738 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
38739 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
38740 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
38741 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
38742 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
38743 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
38744 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
38745 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
38746 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
38747 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
38748 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
38749 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
38750
38751 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
38752 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
38753 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
38754 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
38755
38756 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
38757 }
38758
wxWidgets (Impactor)