]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
don't set cursor for not realized (and not only hidden) windows
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafile swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPoint swig_types[113]
2580 #define SWIGTYPE_p_wxPowerEvent swig_types[114]
2581 #define SWIGTYPE_p_wxProcessEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPyApp swig_types[116]
2583 #define SWIGTYPE_p_wxPyArtProvider swig_types[117]
2584 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[118]
2585 #define SWIGTYPE_p_wxPyCommandEvent swig_types[119]
2586 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropSource swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
2589 #define SWIGTYPE_p_wxPyEvent swig_types[123]
2590 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyImageHandler swig_types[125]
2592 #define SWIGTYPE_p_wxPyLog swig_types[126]
2593 #define SWIGTYPE_p_wxPyProcess swig_types[127]
2594 #define SWIGTYPE_p_wxPySizer swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDataObject swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[130]
2597 #define SWIGTYPE_p_wxPyTimer swig_types[131]
2598 #define SWIGTYPE_p_wxPyTipProvider swig_types[132]
2599 #define SWIGTYPE_p_wxPyValidator swig_types[133]
2600 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[134]
2601 #define SWIGTYPE_p_wxRect swig_types[135]
2602 #define SWIGTYPE_p_wxScrollEvent swig_types[136]
2603 #define SWIGTYPE_p_wxScrollWinEvent swig_types[137]
2604 #define SWIGTYPE_p_wxSetCursorEvent swig_types[138]
2605 #define SWIGTYPE_p_wxShowEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[140]
2607 #define SWIGTYPE_p_wxSize swig_types[141]
2608 #define SWIGTYPE_p_wxSizeEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSizer swig_types[143]
2610 #define SWIGTYPE_p_wxSizerItem swig_types[144]
2611 #define SWIGTYPE_p_wxSound swig_types[145]
2612 #define SWIGTYPE_p_wxStandardPaths swig_types[146]
2613 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStopWatch swig_types[149]
2616 #define SWIGTYPE_p_wxString swig_types[150]
2617 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[151]
2618 #define SWIGTYPE_p_wxSystemOptions swig_types[152]
2619 #define SWIGTYPE_p_wxSystemSettings swig_types[153]
2620 #define SWIGTYPE_p_wxTIFFHandler swig_types[154]
2621 #define SWIGTYPE_p_wxTextCtrl swig_types[155]
2622 #define SWIGTYPE_p_wxTextDataObject swig_types[156]
2623 #define SWIGTYPE_p_wxTimeSpan swig_types[157]
2624 #define SWIGTYPE_p_wxTimer swig_types[158]
2625 #define SWIGTYPE_p_wxTimerEvent swig_types[159]
2626 #define SWIGTYPE_p_wxTimerRunner swig_types[160]
2627 #define SWIGTYPE_p_wxTipProvider swig_types[161]
2628 #define SWIGTYPE_p_wxToolTip swig_types[162]
2629 #define SWIGTYPE_p_wxURLDataObject swig_types[163]
2630 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[164]
2631 #define SWIGTYPE_p_wxValidator swig_types[165]
2632 #define SWIGTYPE_p_wxVideoMode swig_types[166]
2633 #define SWIGTYPE_p_wxWindow swig_types[167]
2634 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDisabler swig_types[170]
2637 #define SWIGTYPE_p_wxXPMHandler swig_types[171]
2638 static swig_type_info *swig_types[173];
2639 static swig_module_info swig_module = {swig_types, 172, 0, 0, 0, 0};
2640 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2641 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2642
2643 /* -------- TYPES TABLE (END) -------- */
2644
2645 #if (PY_VERSION_HEX <= 0x02000000)
2646 # if !defined(SWIG_PYTHON_CLASSIC)
2647 # error "This python version requires to use swig with the '-classic' option"
2648 # endif
2649 #endif
2650 #if (PY_VERSION_HEX <= 0x02020000)
2651 # error "This python version requires to use swig with the '-nomodern' option"
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodernargs' option"
2655 #endif
2656 #ifndef METH_O
2657 # error "This python version requires to use swig with the '-nofastunpack' option"
2658 #endif
2659
2660 /*-----------------------------------------------
2661 @(target):= _misc_.so
2662 ------------------------------------------------*/
2663 #define SWIG_init init_misc_
2664
2665 #define SWIG_name "_misc_"
2666
2667 #define SWIGVERSION 0x010329
2668
2669
2670 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2671 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2672
2673
2674 #include <stdexcept>
2675
2676
2677 namespace swig {
2678 class PyObject_ptr {
2679 protected:
2680 PyObject *_obj;
2681
2682 public:
2683 PyObject_ptr() :_obj(0)
2684 {
2685 }
2686
2687 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2688 {
2689 Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2693 {
2694 if (initial_ref) Py_XINCREF(_obj);
2695 }
2696
2697 PyObject_ptr & operator=(const PyObject_ptr& item)
2698 {
2699 Py_XINCREF(item._obj);
2700 Py_XDECREF(_obj);
2701 _obj = item._obj;
2702 return *this;
2703 }
2704
2705 ~PyObject_ptr()
2706 {
2707 Py_XDECREF(_obj);
2708 }
2709
2710 operator PyObject *() const
2711 {
2712 return _obj;
2713 }
2714
2715 PyObject *operator->() const
2716 {
2717 return _obj;
2718 }
2719 };
2720 }
2721
2722
2723 namespace swig {
2724 struct PyObject_var : PyObject_ptr {
2725 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2726
2727 PyObject_var & operator = (PyObject* obj)
2728 {
2729 Py_XDECREF(_obj);
2730 _obj = obj;
2731 return *this;
2732 }
2733 };
2734 }
2735
2736
2737 #include "wx/wxPython/wxPython.h"
2738 #include "wx/wxPython/pyclasses.h"
2739 #include "wx/wxPython/pyistream.h"
2740
2741 static const wxString wxPyEmptyString(wxEmptyString);
2742
2743
2744
2745 #define SWIG_From_long PyInt_FromLong
2746
2747
2748 SWIGINTERNINLINE PyObject *
2749 SWIG_From_int (int value)
2750 {
2751 return SWIG_From_long (value);
2752 }
2753
2754
2755 #include <limits.h>
2756 #ifndef LLONG_MIN
2757 # define LLONG_MIN LONG_LONG_MIN
2758 #endif
2759 #ifndef LLONG_MAX
2760 # define LLONG_MAX LONG_LONG_MAX
2761 #endif
2762 #ifndef ULLONG_MAX
2763 # define ULLONG_MAX ULONG_LONG_MAX
2764 #endif
2765
2766
2767 SWIGINTERN int
2768 SWIG_AsVal_long (PyObject* obj, long* val)
2769 {
2770 if (PyNumber_Check(obj)) {
2771 if (val) *val = PyInt_AsLong(obj);
2772 return SWIG_OK;
2773 }
2774 return SWIG_TypeError;
2775 }
2776
2777
2778 SWIGINTERN int
2779 SWIG_AsVal_int (PyObject * obj, int *val)
2780 {
2781 long v;
2782 int res = SWIG_AsVal_long (obj, &v);
2783 if (SWIG_IsOK(res)) {
2784 if ((v < INT_MIN || v > INT_MAX)) {
2785 return SWIG_OverflowError;
2786 } else {
2787 if (val) *val = static_cast< int >(v);
2788 }
2789 }
2790 return res;
2791 }
2792
2793 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2794
2795 #include <wx/stockitem.h>
2796
2797 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2798 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2799 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2800
2801 SWIGINTERN int
2802 SWIG_AsVal_bool (PyObject *obj, bool *val)
2803 {
2804 if (obj == Py_True) {
2805 if (val) *val = true;
2806 return SWIG_OK;
2807 } else if (obj == Py_False) {
2808 if (val) *val = false;
2809 return SWIG_OK;
2810 } else {
2811 long v = 0;
2812 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2813 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2814 return res;
2815 }
2816 }
2817
2818
2819 SWIGINTERN int
2820 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2821 {
2822 long v = 0;
2823 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2824 return SWIG_TypeError;
2825 }
2826 else if (val)
2827 *val = (unsigned long)v;
2828 return SWIG_OK;
2829 }
2830
2831
2832 SWIGINTERNINLINE PyObject*
2833 SWIG_From_unsigned_SS_long (unsigned long value)
2834 {
2835 return (value > LONG_MAX) ?
2836 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2837 }
2838
2839
2840 void* wxGetXDisplay()
2841 {
2842 #ifdef __WXGTK__
2843 return wxGetDisplay();
2844 #else
2845 return NULL;
2846 #endif
2847 }
2848
2849
2850 wxWindow* FindWindowAtPointer() {
2851 wxPoint unused;
2852 return wxFindWindowAtPointer(unused);
2853 }
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 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3541 PyObject* ret = PyTuple_New(3);
3542 if (ret) {
3543 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3544 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3545 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3546 }
3547 wxPyEndBlockThreads(blocked);
3548 return ret;
3549 }
3550
3551 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3552 bool cont;
3553 long index = 0;
3554 wxString value;
3555
3556 cont = self->GetFirstGroup(value, index);
3557 return __EnumerationHelper(cont, value, index);
3558 }
3559 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3560 bool cont;
3561 wxString value;
3562
3563 cont = self->GetNextGroup(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3567 bool cont;
3568 long index = 0;
3569 wxString value;
3570
3571 cont = self->GetFirstEntry(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3575 bool cont;
3576 wxString value;
3577
3578 cont = self->GetNextEntry(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3582 long rv;
3583 self->Read(key, &rv, defaultVal);
3584 return rv;
3585 }
3586
3587 SWIGINTERN int
3588 SWIG_AsVal_double (PyObject *obj, double* val)
3589 {
3590 if (PyNumber_Check(obj)) {
3591 if (val) *val = PyFloat_AsDouble(obj);
3592 return SWIG_OK;
3593 }
3594 return SWIG_TypeError;
3595 }
3596
3597 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3598 double rv;
3599 self->Read(key, &rv, defaultVal);
3600 return rv;
3601 }
3602
3603 #define SWIG_From_double PyFloat_FromDouble
3604
3605 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3606 bool rv;
3607 self->Read(key, &rv, defaultVal);
3608 return rv;
3609 }
3610
3611 #include <wx/datetime.h>
3612
3613 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3614 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3615
3616 #define LOCAL_TZ wxDateTime::Local
3617
3618 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3619 wxString am;
3620 wxString pm;
3621 wxDateTime::GetAmPmStrings(&am, &pm);
3622 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3623 PyObject* tup = PyTuple_New(2);
3624 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3625 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3626 wxPyEndBlockThreads(blocked);
3627 return tup;
3628 }
3629
3630 SWIGINTERNINLINE PyObject *
3631 SWIG_From_unsigned_SS_int (unsigned int value)
3632 {
3633 return SWIG_From_unsigned_SS_long (value);
3634 }
3635
3636 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3638 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3639 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3641 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3642 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3643 return (*self < *other);
3644 }
3645 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3646 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3647 return (*self <= *other);
3648 }
3649 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3651 return (*self > *other);
3652 }
3653 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3655 return (*self >= *other);
3656 }
3657 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3659 return (*self == *other);
3660 }
3661 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3662 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3663 return (*self != *other);
3664 }
3665 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3666 const wxChar* rv;
3667 const wxChar* _date = date;
3668 rv = self->ParseRfc822Date(_date);
3669 if (rv == NULL) return -1;
3670 return rv - _date;
3671 }
3672 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3673 const wxChar* rv;
3674 const wxChar* _date = date;
3675 rv = self->ParseFormat(_date, format, dateDef);
3676 if (rv == NULL) return -1;
3677 return rv - _date;
3678 }
3679 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3680 const wxChar* rv;
3681 const wxChar* _datetime = datetime;
3682 rv = self->ParseDateTime(_datetime);
3683 if (rv == NULL) return -1;
3684 return rv - _datetime;
3685 }
3686 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3687 const wxChar* rv;
3688 const wxChar* _date = date;
3689 rv = self->ParseDate(_date);
3690 if (rv == NULL) return -1;
3691 return rv - _date;
3692 }
3693 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3694 const wxChar* rv;
3695 const wxChar* _time = time;
3696 rv = self->ParseTime(_time);
3697 if (rv == NULL) return -1;
3698 return rv - _time;
3699 }
3700 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3704 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3705 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3707 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3709 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3710 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3711 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3713 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3714 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3715 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3716
3717 #include <wx/dataobj.h>
3718
3719 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3720 size_t count = self->GetFormatCount(dir);
3721 wxDataFormat* formats = new wxDataFormat[count];
3722 self->GetAllFormats(formats, dir);
3723
3724 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3725 PyObject* list = PyList_New(count);
3726 for (size_t i=0; i<count; i++) {
3727 wxDataFormat* format = new wxDataFormat(formats[i]);
3728 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3729 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3730 }
3731 wxPyEndBlockThreads(blocked);
3732 delete [] formats;
3733 return list;
3734 }
3735 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3736 PyObject* rval = NULL;
3737 size_t size = self->GetDataSize(format);
3738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3739 if (size) {
3740 char* buf = new char[size];
3741 if (self->GetDataHere(format, buf))
3742 rval = PyString_FromStringAndSize(buf, size);
3743 delete [] buf;
3744 }
3745 if (! rval) {
3746 rval = Py_None;
3747 Py_INCREF(rval);
3748 }
3749 wxPyEndBlockThreads(blocked);
3750 return rval;
3751 }
3752 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3753 bool rval;
3754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3755 if (PyString_Check(data)) {
3756 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3757 }
3758 else {
3759 // raise a TypeError if not a string
3760 PyErr_SetString(PyExc_TypeError, "String expected.");
3761 rval = false;
3762 }
3763 wxPyEndBlockThreads(blocked);
3764 return rval;
3765 }
3766 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3767 PyObject* rval = NULL;
3768 size_t size = self->GetDataSize();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 if (size) {
3771 char* buf = new char[size];
3772 if (self->GetDataHere(buf))
3773 rval = PyString_FromStringAndSize(buf, size);
3774 delete [] buf;
3775 }
3776 if (! rval) {
3777 rval = Py_None;
3778 Py_INCREF(rval);
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return rval;
3782 }
3783 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3784 bool rval;
3785 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3786 if (PyString_Check(data)) {
3787 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3788 }
3789 else {
3790 // raise a TypeError if not a string
3791 PyErr_SetString(PyExc_TypeError, "String expected.");
3792 rval = false;
3793 }
3794 wxPyEndBlockThreads(blocked);
3795 return rval;
3796 }
3797 // Create a new class for wxPython to use
3798 class wxPyDataObjectSimple : public wxDataObjectSimple {
3799 public:
3800 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3801 : wxDataObjectSimple(format) {}
3802
3803 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3804 bool GetDataHere(void *buf) const;
3805 bool SetData(size_t len, const void *buf);
3806 PYPRIVATE;
3807 };
3808
3809 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3810
3811 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3812 // We need to get the data for this object and write it to buf. I think
3813 // the best way to do this for wxPython is to have the Python method
3814 // return either a string or None and then act appropriately with the
3815 // C++ version.
3816
3817 bool rval = false;
3818 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3819 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3820 PyObject* ro;
3821 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3822 if (ro) {
3823 rval = (ro != Py_None && PyString_Check(ro));
3824 if (rval)
3825 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3826 Py_DECREF(ro);
3827 }
3828 }
3829 wxPyEndBlockThreads(blocked);
3830 return rval;
3831 }
3832
3833 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3834 // For this one we simply need to make a string from buf and len
3835 // and send it to the Python method.
3836 bool rval = false;
3837 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3838 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3839 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3840 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3841 Py_DECREF(data);
3842 }
3843 wxPyEndBlockThreads(blocked);
3844 return rval;
3845 }
3846
3847 // Create a new class for wxPython to use
3848 class wxPyTextDataObject : public wxTextDataObject {
3849 public:
3850 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3851 : wxTextDataObject(text) {}
3852
3853 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3854 DEC_PYCALLBACK_STRING__const(GetText);
3855 DEC_PYCALLBACK__STRING(SetText);
3856 PYPRIVATE;
3857 };
3858
3859 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3860 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3861 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3862
3863
3864 // Create a new class for wxPython to use
3865 class wxPyBitmapDataObject : public wxBitmapDataObject {
3866 public:
3867 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3868 : wxBitmapDataObject(bitmap) {}
3869
3870 wxBitmap GetBitmap() const;
3871 void SetBitmap(const wxBitmap& bitmap);
3872 PYPRIVATE;
3873 };
3874
3875 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3876 wxBitmap* rval = &wxNullBitmap;
3877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3878 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3879 PyObject* ro;
3880 wxBitmap* ptr;
3881 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3882 if (ro) {
3883 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3884 rval = ptr;
3885 Py_DECREF(ro);
3886 }
3887 }
3888 wxPyEndBlockThreads(blocked);
3889 return *rval;
3890 }
3891
3892 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3893 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3894 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3895 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3896 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3897 Py_DECREF(bo);
3898 }
3899 wxPyEndBlockThreads(blocked);
3900 }
3901
3902 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3903 return new wxCustomDataObject(wxDataFormat(formatName));
3904 }
3905 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3906 bool rval;
3907 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3908 if (PyString_Check(data)) {
3909 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3910 }
3911 else {
3912 // raise a TypeError if not a string
3913 PyErr_SetString(PyExc_TypeError, "String expected.");
3914 rval = false;
3915 }
3916 wxPyEndBlockThreads(blocked);
3917 return rval;
3918 }
3919 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3920 PyObject* obj;
3921 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3922 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3923 wxPyEndBlockThreads(blocked);
3924 return obj;
3925 }
3926
3927 #include <wx/metafile.h>
3928
3929
3930 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3931
3932
3933 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3934 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3935 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3936 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3937 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3938
3939
3940 class wxPyTextDropTarget : public wxTextDropTarget {
3941 public:
3942 wxPyTextDropTarget() {}
3943
3944 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3945
3946 DEC_PYCALLBACK__(OnLeave);
3947 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3950 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3951
3952 PYPRIVATE;
3953 };
3954
3955 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3956 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3957 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3960 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3961
3962
3963
3964 class wxPyFileDropTarget : public wxFileDropTarget {
3965 public:
3966 wxPyFileDropTarget() {}
3967
3968 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3969
3970 DEC_PYCALLBACK__(OnLeave);
3971 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3974 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3975
3976 PYPRIVATE;
3977 };
3978
3979 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3980 const wxArrayString& filenames) {
3981 bool rval = false;
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3984 PyObject* list = wxArrayString2PyList_helper(filenames);
3985 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3986 Py_DECREF(list);
3987 }
3988 wxPyEndBlockThreads(blocked);
3989 return rval;
3990 }
3991
3992
3993
3994 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3995 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3998 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3999
4000
4001
4002
4003 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4004
4005 #include <wx/display.h>
4006
4007 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4008 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4009
4010 #if !wxUSE_DISPLAY
4011 const wxVideoMode wxDefaultVideoMode;
4012 #endif
4013
4014 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4015 #if wxUSE_DISPLAY
4016 PyObject* pyList = NULL;
4017 wxArrayVideoModes arr = self->GetModes(mode);
4018 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4019 pyList = PyList_New(0);
4020 for (size_t i=0; i < arr.GetCount(); i++)
4021 {
4022 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4023 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4024 PyList_Append(pyList, pyObj);
4025 Py_DECREF(pyObj);
4026 }
4027 wxPyEndBlockThreads(blocked);
4028 return pyList;
4029 #else
4030 wxPyRaiseNotImplemented();
4031 return NULL;
4032 #endif
4033 }
4034 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4035 #if wxUSE_DISPLAY
4036 return self->GetCurrentMode();
4037 #else
4038 wxPyRaiseNotImplemented();
4039 return wxDefaultVideoMode;
4040 #endif
4041 }
4042 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4043 #if wxUSE_DISPLAY
4044 return self->ChangeMode(mode);
4045 #else
4046 wxPyRaiseNotImplemented();
4047 return false;
4048 #endif
4049 }
4050 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4051 #if wxUSE_DISPLAY
4052 self->ResetMode();
4053 #else
4054 wxPyRaiseNotImplemented();
4055 #endif
4056 }
4057
4058 #include <wx/stdpaths.h>
4059
4060 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4061 return (wxStandardPaths*) &wxStandardPaths::Get();
4062 }
4063 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4064 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4065
4066 #ifndef wxHAS_POWER_EVENTS
4067 // Dummy class and other definitions for platforms that don't have them
4068
4069 // See wxPython_int.h for wxPowerEvent
4070
4071 enum {
4072 wxEVT_POWER_SUSPENDING,
4073 wxEVT_POWER_SUSPENDED,
4074 wxEVT_POWER_SUSPEND_CANCEL,
4075 wxEVT_POWER_RESUME,
4076 };
4077
4078 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4079 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4080
4081 #endif
4082
4083 #ifdef __cplusplus
4084 extern "C" {
4085 #endif
4086 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4087 PyObject *resultobj = 0;
4088 wxSystemColour arg1 ;
4089 wxColour result;
4090 int val1 ;
4091 int ecode1 = 0 ;
4092 PyObject * obj0 = 0 ;
4093 char * kwnames[] = {
4094 (char *) "index", NULL
4095 };
4096
4097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4098 ecode1 = SWIG_AsVal_int(obj0, &val1);
4099 if (!SWIG_IsOK(ecode1)) {
4100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4101 }
4102 arg1 = static_cast< wxSystemColour >(val1);
4103 {
4104 if (!wxPyCheckForApp()) SWIG_fail;
4105 PyThreadState* __tstate = wxPyBeginAllowThreads();
4106 result = wxSystemSettings::GetColour(arg1);
4107 wxPyEndAllowThreads(__tstate);
4108 if (PyErr_Occurred()) SWIG_fail;
4109 }
4110 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4111 return resultobj;
4112 fail:
4113 return NULL;
4114 }
4115
4116
4117 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4118 PyObject *resultobj = 0;
4119 wxSystemFont arg1 ;
4120 wxFont result;
4121 int val1 ;
4122 int ecode1 = 0 ;
4123 PyObject * obj0 = 0 ;
4124 char * kwnames[] = {
4125 (char *) "index", NULL
4126 };
4127
4128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4129 ecode1 = SWIG_AsVal_int(obj0, &val1);
4130 if (!SWIG_IsOK(ecode1)) {
4131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4132 }
4133 arg1 = static_cast< wxSystemFont >(val1);
4134 {
4135 if (!wxPyCheckForApp()) SWIG_fail;
4136 PyThreadState* __tstate = wxPyBeginAllowThreads();
4137 result = wxSystemSettings::GetFont(arg1);
4138 wxPyEndAllowThreads(__tstate);
4139 if (PyErr_Occurred()) SWIG_fail;
4140 }
4141 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj = 0;
4150 wxSystemMetric arg1 ;
4151 wxWindow *arg2 = (wxWindow *) NULL ;
4152 int result;
4153 int val1 ;
4154 int ecode1 = 0 ;
4155 void *argp2 = 0 ;
4156 int res2 = 0 ;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 char * kwnames[] = {
4160 (char *) "index",(char *) "win", NULL
4161 };
4162
4163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4164 ecode1 = SWIG_AsVal_int(obj0, &val1);
4165 if (!SWIG_IsOK(ecode1)) {
4166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4167 }
4168 arg1 = static_cast< wxSystemMetric >(val1);
4169 if (obj1) {
4170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4171 if (!SWIG_IsOK(res2)) {
4172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4173 }
4174 arg2 = reinterpret_cast< wxWindow * >(argp2);
4175 }
4176 {
4177 if (!wxPyCheckForApp()) SWIG_fail;
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4180 wxPyEndAllowThreads(__tstate);
4181 if (PyErr_Occurred()) SWIG_fail;
4182 }
4183 resultobj = SWIG_From_int(static_cast< int >(result));
4184 return resultobj;
4185 fail:
4186 return NULL;
4187 }
4188
4189
4190 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4191 PyObject *resultobj = 0;
4192 wxSystemFeature arg1 ;
4193 bool result;
4194 int val1 ;
4195 int ecode1 = 0 ;
4196 PyObject * obj0 = 0 ;
4197 char * kwnames[] = {
4198 (char *) "index", NULL
4199 };
4200
4201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4202 ecode1 = SWIG_AsVal_int(obj0, &val1);
4203 if (!SWIG_IsOK(ecode1)) {
4204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4205 }
4206 arg1 = static_cast< wxSystemFeature >(val1);
4207 {
4208 if (!wxPyCheckForApp()) SWIG_fail;
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (bool)wxSystemSettings::HasFeature(arg1);
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4216 }
4217 return resultobj;
4218 fail:
4219 return NULL;
4220 }
4221
4222
4223 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4224 PyObject *resultobj = 0;
4225 wxSystemScreenType result;
4226
4227 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4228 {
4229 if (!wxPyCheckForApp()) SWIG_fail;
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 resultobj = SWIG_From_int(static_cast< int >(result));
4236 return resultobj;
4237 fail:
4238 return NULL;
4239 }
4240
4241
4242 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4243 PyObject *resultobj = 0;
4244 wxSystemScreenType arg1 ;
4245 int val1 ;
4246 int ecode1 = 0 ;
4247 PyObject * obj0 = 0 ;
4248 char * kwnames[] = {
4249 (char *) "screen", NULL
4250 };
4251
4252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4253 ecode1 = SWIG_AsVal_int(obj0, &val1);
4254 if (!SWIG_IsOK(ecode1)) {
4255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4256 }
4257 arg1 = static_cast< wxSystemScreenType >(val1);
4258 {
4259 if (!wxPyCheckForApp()) SWIG_fail;
4260 PyThreadState* __tstate = wxPyBeginAllowThreads();
4261 wxSystemSettings::SetScreenType(arg1);
4262 wxPyEndAllowThreads(__tstate);
4263 if (PyErr_Occurred()) SWIG_fail;
4264 }
4265 resultobj = SWIG_Py_Void();
4266 return resultobj;
4267 fail:
4268 return NULL;
4269 }
4270
4271
4272 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4273 PyObject *obj;
4274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4275 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4276 return SWIG_Py_Void();
4277 }
4278
4279 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4280 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4281 return 1;
4282 }
4283
4284
4285 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4286 PyObject *pyobj = 0;
4287
4288 {
4289 #if wxUSE_UNICODE
4290 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4291 #else
4292 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4293 #endif
4294 }
4295 return pyobj;
4296 }
4297
4298
4299 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4300 PyObject *resultobj = 0;
4301 wxSystemOptions *result = 0 ;
4302
4303 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4304 {
4305 PyThreadState* __tstate = wxPyBeginAllowThreads();
4306 result = (wxSystemOptions *)new wxSystemOptions();
4307 wxPyEndAllowThreads(__tstate);
4308 if (PyErr_Occurred()) SWIG_fail;
4309 }
4310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4311 return resultobj;
4312 fail:
4313 return NULL;
4314 }
4315
4316
4317 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4318 PyObject *resultobj = 0;
4319 wxString *arg1 = 0 ;
4320 wxString *arg2 = 0 ;
4321 bool temp1 = false ;
4322 bool temp2 = false ;
4323 PyObject * obj0 = 0 ;
4324 PyObject * obj1 = 0 ;
4325 char * kwnames[] = {
4326 (char *) "name",(char *) "value", NULL
4327 };
4328
4329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4330 {
4331 arg1 = wxString_in_helper(obj0);
4332 if (arg1 == NULL) SWIG_fail;
4333 temp1 = true;
4334 }
4335 {
4336 arg2 = wxString_in_helper(obj1);
4337 if (arg2 == NULL) SWIG_fail;
4338 temp2 = true;
4339 }
4340 {
4341 PyThreadState* __tstate = wxPyBeginAllowThreads();
4342 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4343 wxPyEndAllowThreads(__tstate);
4344 if (PyErr_Occurred()) SWIG_fail;
4345 }
4346 resultobj = SWIG_Py_Void();
4347 {
4348 if (temp1)
4349 delete arg1;
4350 }
4351 {
4352 if (temp2)
4353 delete arg2;
4354 }
4355 return resultobj;
4356 fail:
4357 {
4358 if (temp1)
4359 delete arg1;
4360 }
4361 {
4362 if (temp2)
4363 delete arg2;
4364 }
4365 return NULL;
4366 }
4367
4368
4369 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj = 0;
4371 wxString *arg1 = 0 ;
4372 int arg2 ;
4373 bool temp1 = false ;
4374 int val2 ;
4375 int ecode2 = 0 ;
4376 PyObject * obj0 = 0 ;
4377 PyObject * obj1 = 0 ;
4378 char * kwnames[] = {
4379 (char *) "name",(char *) "value", NULL
4380 };
4381
4382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4383 {
4384 arg1 = wxString_in_helper(obj0);
4385 if (arg1 == NULL) SWIG_fail;
4386 temp1 = true;
4387 }
4388 ecode2 = SWIG_AsVal_int(obj1, &val2);
4389 if (!SWIG_IsOK(ecode2)) {
4390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4391 }
4392 arg2 = static_cast< int >(val2);
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 resultobj = SWIG_Py_Void();
4400 {
4401 if (temp1)
4402 delete arg1;
4403 }
4404 return resultobj;
4405 fail:
4406 {
4407 if (temp1)
4408 delete arg1;
4409 }
4410 return NULL;
4411 }
4412
4413
4414 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4415 PyObject *resultobj = 0;
4416 wxString *arg1 = 0 ;
4417 wxString result;
4418 bool temp1 = false ;
4419 PyObject * obj0 = 0 ;
4420 char * kwnames[] = {
4421 (char *) "name", NULL
4422 };
4423
4424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4425 {
4426 arg1 = wxString_in_helper(obj0);
4427 if (arg1 == NULL) SWIG_fail;
4428 temp1 = true;
4429 }
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 #if wxUSE_UNICODE
4438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4439 #else
4440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4441 #endif
4442 }
4443 {
4444 if (temp1)
4445 delete arg1;
4446 }
4447 return resultobj;
4448 fail:
4449 {
4450 if (temp1)
4451 delete arg1;
4452 }
4453 return NULL;
4454 }
4455
4456
4457 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4458 PyObject *resultobj = 0;
4459 wxString *arg1 = 0 ;
4460 int result;
4461 bool temp1 = false ;
4462 PyObject * obj0 = 0 ;
4463 char * kwnames[] = {
4464 (char *) "name", NULL
4465 };
4466
4467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4468 {
4469 arg1 = wxString_in_helper(obj0);
4470 if (arg1 == NULL) SWIG_fail;
4471 temp1 = true;
4472 }
4473 {
4474 PyThreadState* __tstate = wxPyBeginAllowThreads();
4475 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 resultobj = SWIG_From_int(static_cast< int >(result));
4480 {
4481 if (temp1)
4482 delete arg1;
4483 }
4484 return resultobj;
4485 fail:
4486 {
4487 if (temp1)
4488 delete arg1;
4489 }
4490 return NULL;
4491 }
4492
4493
4494 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj = 0;
4496 wxString *arg1 = 0 ;
4497 bool result;
4498 bool temp1 = false ;
4499 PyObject * obj0 = 0 ;
4500 char * kwnames[] = {
4501 (char *) "name", NULL
4502 };
4503
4504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4505 {
4506 arg1 = wxString_in_helper(obj0);
4507 if (arg1 == NULL) SWIG_fail;
4508 temp1 = true;
4509 }
4510 {
4511 PyThreadState* __tstate = wxPyBeginAllowThreads();
4512 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4513 wxPyEndAllowThreads(__tstate);
4514 if (PyErr_Occurred()) SWIG_fail;
4515 }
4516 {
4517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4518 }
4519 {
4520 if (temp1)
4521 delete arg1;
4522 }
4523 return resultobj;
4524 fail:
4525 {
4526 if (temp1)
4527 delete arg1;
4528 }
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4534 PyObject *resultobj = 0;
4535 wxString *arg1 = 0 ;
4536 bool result;
4537 bool temp1 = false ;
4538 PyObject * obj0 = 0 ;
4539 char * kwnames[] = {
4540 (char *) "name", NULL
4541 };
4542
4543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4544 {
4545 arg1 = wxString_in_helper(obj0);
4546 if (arg1 == NULL) SWIG_fail;
4547 temp1 = true;
4548 }
4549 {
4550 PyThreadState* __tstate = wxPyBeginAllowThreads();
4551 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4552 wxPyEndAllowThreads(__tstate);
4553 if (PyErr_Occurred()) SWIG_fail;
4554 }
4555 {
4556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4557 }
4558 {
4559 if (temp1)
4560 delete arg1;
4561 }
4562 return resultobj;
4563 fail:
4564 {
4565 if (temp1)
4566 delete arg1;
4567 }
4568 return NULL;
4569 }
4570
4571
4572 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573 PyObject *obj;
4574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4575 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4576 return SWIG_Py_Void();
4577 }
4578
4579 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580 return SWIG_Python_InitShadowInstance(args);
4581 }
4582
4583 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4584 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4585 return 1;
4586 }
4587
4588
4589 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4590 PyObject *pyobj = 0;
4591
4592 {
4593 #if wxUSE_UNICODE
4594 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4595 #else
4596 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4597 #endif
4598 }
4599 return pyobj;
4600 }
4601
4602
4603 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4604 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4605 return 1;
4606 }
4607
4608
4609 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4610 PyObject *pyobj = 0;
4611
4612 {
4613 #if wxUSE_UNICODE
4614 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4615 #else
4616 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4617 #endif
4618 }
4619 return pyobj;
4620 }
4621
4622
4623 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4624 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4625 return 1;
4626 }
4627
4628
4629 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4630 PyObject *pyobj = 0;
4631
4632 {
4633 #if wxUSE_UNICODE
4634 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4635 #else
4636 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4637 #endif
4638 }
4639 return pyobj;
4640 }
4641
4642
4643 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4644 PyObject *resultobj = 0;
4645 long result;
4646
4647 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4648 {
4649 PyThreadState* __tstate = wxPyBeginAllowThreads();
4650 result = (long)wxNewId();
4651 wxPyEndAllowThreads(__tstate);
4652 if (PyErr_Occurred()) SWIG_fail;
4653 }
4654 resultobj = SWIG_From_long(static_cast< long >(result));
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj = 0;
4663 long arg1 ;
4664 long val1 ;
4665 int ecode1 = 0 ;
4666 PyObject * obj0 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "id", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4672 ecode1 = SWIG_AsVal_long(obj0, &val1);
4673 if (!SWIG_IsOK(ecode1)) {
4674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4675 }
4676 arg1 = static_cast< long >(val1);
4677 {
4678 PyThreadState* __tstate = wxPyBeginAllowThreads();
4679 wxRegisterId(arg1);
4680 wxPyEndAllowThreads(__tstate);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 resultobj = SWIG_Py_Void();
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4691 PyObject *resultobj = 0;
4692 long result;
4693
4694 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4695 {
4696 PyThreadState* __tstate = wxPyBeginAllowThreads();
4697 result = (long)wxGetCurrentId();
4698 wxPyEndAllowThreads(__tstate);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 resultobj = SWIG_From_long(static_cast< long >(result));
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = 0;
4710 int arg1 ;
4711 bool result;
4712 int val1 ;
4713 int ecode1 = 0 ;
4714 PyObject * obj0 = 0 ;
4715 char * kwnames[] = {
4716 (char *) "id", NULL
4717 };
4718
4719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4720 ecode1 = SWIG_AsVal_int(obj0, &val1);
4721 if (!SWIG_IsOK(ecode1)) {
4722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4723 }
4724 arg1 = static_cast< int >(val1);
4725 {
4726 PyThreadState* __tstate = wxPyBeginAllowThreads();
4727 result = (bool)wxIsStockID(arg1);
4728 wxPyEndAllowThreads(__tstate);
4729 if (PyErr_Occurred()) SWIG_fail;
4730 }
4731 {
4732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4733 }
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj = 0;
4742 int arg1 ;
4743 wxString *arg2 = 0 ;
4744 bool result;
4745 int val1 ;
4746 int ecode1 = 0 ;
4747 bool temp2 = false ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
4751 (char *) "id",(char *) "label", NULL
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4755 ecode1 = SWIG_AsVal_int(obj0, &val1);
4756 if (!SWIG_IsOK(ecode1)) {
4757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4758 }
4759 arg1 = static_cast< int >(val1);
4760 {
4761 arg2 = wxString_in_helper(obj1);
4762 if (arg2 == NULL) SWIG_fail;
4763 temp2 = true;
4764 }
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 {
4772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4773 }
4774 {
4775 if (temp2)
4776 delete arg2;
4777 }
4778 return resultobj;
4779 fail:
4780 {
4781 if (temp2)
4782 delete arg2;
4783 }
4784 return NULL;
4785 }
4786
4787
4788 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4789 PyObject *resultobj = 0;
4790 int arg1 ;
4791 bool arg2 = (bool) true ;
4792 wxString arg3 = (wxString) wxPyEmptyString ;
4793 wxString result;
4794 int val1 ;
4795 int ecode1 = 0 ;
4796 bool val2 ;
4797 int ecode2 = 0 ;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4800 PyObject * obj2 = 0 ;
4801 char * kwnames[] = {
4802 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4803 };
4804
4805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4806 ecode1 = SWIG_AsVal_int(obj0, &val1);
4807 if (!SWIG_IsOK(ecode1)) {
4808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4809 }
4810 arg1 = static_cast< int >(val1);
4811 if (obj1) {
4812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4813 if (!SWIG_IsOK(ecode2)) {
4814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4815 }
4816 arg2 = static_cast< bool >(val2);
4817 }
4818 if (obj2) {
4819 {
4820 wxString* sptr = wxString_in_helper(obj2);
4821 if (sptr == NULL) SWIG_fail;
4822 arg3 = *sptr;
4823 delete sptr;
4824 }
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 result = wxGetStockLabel(arg1,arg2,arg3);
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 {
4833 #if wxUSE_UNICODE
4834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4835 #else
4836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4837 #endif
4838 }
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846 PyObject *resultobj = 0;
4847
4848 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4849 {
4850 if (!wxPyCheckForApp()) SWIG_fail;
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 wxBell();
4853 wxPyEndAllowThreads(__tstate);
4854 if (PyErr_Occurred()) SWIG_fail;
4855 }
4856 resultobj = SWIG_Py_Void();
4857 return resultobj;
4858 fail:
4859 return NULL;
4860 }
4861
4862
4863 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4864 PyObject *resultobj = 0;
4865
4866 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4867 {
4868 if (!wxPyCheckForApp()) SWIG_fail;
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 wxEndBusyCursor();
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_Py_Void();
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 bool arg1 = (bool) true ;
4884 long result;
4885 bool val1 ;
4886 int ecode1 = 0 ;
4887 PyObject * obj0 = 0 ;
4888 char * kwnames[] = {
4889 (char *) "resetTimer", NULL
4890 };
4891
4892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4893 if (obj0) {
4894 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4895 if (!SWIG_IsOK(ecode1)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4897 }
4898 arg1 = static_cast< bool >(val1);
4899 }
4900 {
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 result = (long)wxGetElapsedTime(arg1);
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_From_long(static_cast< long >(result));
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4914 PyObject *resultobj = 0;
4915 bool result;
4916
4917 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 result = (bool)wxIsBusy();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 {
4925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4926 }
4927 return resultobj;
4928 fail:
4929 return NULL;
4930 }
4931
4932
4933 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4934 PyObject *resultobj = 0;
4935 wxString result;
4936
4937 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = wxNow();
4941 wxPyEndAllowThreads(__tstate);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 {
4945 #if wxUSE_UNICODE
4946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4947 #else
4948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4949 #endif
4950 }
4951 return resultobj;
4952 fail:
4953 return NULL;
4954 }
4955
4956
4957 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4958 PyObject *resultobj = 0;
4959 wxString const &arg1_defvalue = wxPyEmptyString ;
4960 wxString *arg1 = (wxString *) &arg1_defvalue ;
4961 bool result;
4962 bool temp1 = false ;
4963 PyObject * obj0 = 0 ;
4964 char * kwnames[] = {
4965 (char *) "command", NULL
4966 };
4967
4968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4969 if (obj0) {
4970 {
4971 arg1 = wxString_in_helper(obj0);
4972 if (arg1 == NULL) SWIG_fail;
4973 temp1 = true;
4974 }
4975 }
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (bool)wxShell((wxString const &)*arg1);
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4984 }
4985 {
4986 if (temp1)
4987 delete arg1;
4988 }
4989 return resultobj;
4990 fail:
4991 {
4992 if (temp1)
4993 delete arg1;
4994 }
4995 return NULL;
4996 }
4997
4998
4999 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5000 PyObject *resultobj = 0;
5001
5002 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5003 {
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 wxStartTimer();
5006 wxPyEndAllowThreads(__tstate);
5007 if (PyErr_Occurred()) SWIG_fail;
5008 }
5009 resultobj = SWIG_Py_Void();
5010 return resultobj;
5011 fail:
5012 return NULL;
5013 }
5014
5015
5016 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5017 PyObject *resultobj = 0;
5018 int *arg1 = (int *) 0 ;
5019 int *arg2 = (int *) 0 ;
5020 int result;
5021 int temp1 ;
5022 int res1 = SWIG_TMPOBJ ;
5023 int temp2 ;
5024 int res2 = SWIG_TMPOBJ ;
5025
5026 arg1 = &temp1;
5027 arg2 = &temp2;
5028 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5029 {
5030 PyThreadState* __tstate = wxPyBeginAllowThreads();
5031 result = (int)wxGetOsVersion(arg1,arg2);
5032 wxPyEndAllowThreads(__tstate);
5033 if (PyErr_Occurred()) SWIG_fail;
5034 }
5035 resultobj = SWIG_From_int(static_cast< int >(result));
5036 if (SWIG_IsTmpObj(res1)) {
5037 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5038 } else {
5039 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5040 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5041 }
5042 if (SWIG_IsTmpObj(res2)) {
5043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5044 } else {
5045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5055 PyObject *resultobj = 0;
5056 wxString result;
5057
5058 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5059 {
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 result = wxGetOsDescription();
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 {
5066 #if wxUSE_UNICODE
5067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5068 #else
5069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5070 #endif
5071 }
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5079 PyObject *resultobj = 0;
5080 wxMemorySize result;
5081
5082 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = wxGetFreeMemory();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 {
5090 #if wxUSE_LONGLONG
5091 resultobj = PyLong_FromLongLong((&result)->GetValue());
5092 #else
5093 resultobj = PyInt_FromLong(result);
5094 #endif
5095 }
5096 return resultobj;
5097 fail:
5098 return NULL;
5099 }
5100
5101
5102 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5103 PyObject *resultobj = 0;
5104 wxShutdownFlags arg1 ;
5105 bool result;
5106 int val1 ;
5107 int ecode1 = 0 ;
5108 PyObject * obj0 = 0 ;
5109 char * kwnames[] = {
5110 (char *) "wFlags", NULL
5111 };
5112
5113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5114 ecode1 = SWIG_AsVal_int(obj0, &val1);
5115 if (!SWIG_IsOK(ecode1)) {
5116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5117 }
5118 arg1 = static_cast< wxShutdownFlags >(val1);
5119 {
5120 if (!wxPyCheckForApp()) SWIG_fail;
5121 PyThreadState* __tstate = wxPyBeginAllowThreads();
5122 result = (bool)wxShutdown(arg1);
5123 wxPyEndAllowThreads(__tstate);
5124 if (PyErr_Occurred()) SWIG_fail;
5125 }
5126 {
5127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5128 }
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5136 PyObject *resultobj = 0;
5137 int arg1 ;
5138 int val1 ;
5139 int ecode1 = 0 ;
5140 PyObject * obj0 = 0 ;
5141 char * kwnames[] = {
5142 (char *) "secs", NULL
5143 };
5144
5145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5146 ecode1 = SWIG_AsVal_int(obj0, &val1);
5147 if (!SWIG_IsOK(ecode1)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5149 }
5150 arg1 = static_cast< int >(val1);
5151 {
5152 PyThreadState* __tstate = wxPyBeginAllowThreads();
5153 wxSleep(arg1);
5154 wxPyEndAllowThreads(__tstate);
5155 if (PyErr_Occurred()) SWIG_fail;
5156 }
5157 resultobj = SWIG_Py_Void();
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5165 PyObject *resultobj = 0;
5166 unsigned long arg1 ;
5167 unsigned long val1 ;
5168 int ecode1 = 0 ;
5169 PyObject * obj0 = 0 ;
5170 char * kwnames[] = {
5171 (char *) "milliseconds", NULL
5172 };
5173
5174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5175 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5176 if (!SWIG_IsOK(ecode1)) {
5177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5178 }
5179 arg1 = static_cast< unsigned long >(val1);
5180 {
5181 PyThreadState* __tstate = wxPyBeginAllowThreads();
5182 wxMilliSleep(arg1);
5183 wxPyEndAllowThreads(__tstate);
5184 if (PyErr_Occurred()) SWIG_fail;
5185 }
5186 resultobj = SWIG_Py_Void();
5187 return resultobj;
5188 fail:
5189 return NULL;
5190 }
5191
5192
5193 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5194 PyObject *resultobj = 0;
5195 unsigned long arg1 ;
5196 unsigned long val1 ;
5197 int ecode1 = 0 ;
5198 PyObject * obj0 = 0 ;
5199 char * kwnames[] = {
5200 (char *) "microseconds", NULL
5201 };
5202
5203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5204 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5205 if (!SWIG_IsOK(ecode1)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5207 }
5208 arg1 = static_cast< unsigned long >(val1);
5209 {
5210 PyThreadState* __tstate = wxPyBeginAllowThreads();
5211 wxMicroSleep(arg1);
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 resultobj = SWIG_Py_Void();
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 bool arg1 ;
5225 bool val1 ;
5226 int ecode1 = 0 ;
5227 PyObject * obj0 = 0 ;
5228 char * kwnames[] = {
5229 (char *) "enable", NULL
5230 };
5231
5232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5233 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5234 if (!SWIG_IsOK(ecode1)) {
5235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5236 }
5237 arg1 = static_cast< bool >(val1);
5238 {
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 wxEnableTopLevelWindows(arg1);
5241 wxPyEndAllowThreads(__tstate);
5242 if (PyErr_Occurred()) SWIG_fail;
5243 }
5244 resultobj = SWIG_Py_Void();
5245 return resultobj;
5246 fail:
5247 return NULL;
5248 }
5249
5250
5251 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5252 PyObject *resultobj = 0;
5253 wxString *arg1 = 0 ;
5254 wxString result;
5255 bool temp1 = false ;
5256 PyObject * obj0 = 0 ;
5257 char * kwnames[] = {
5258 (char *) "in", NULL
5259 };
5260
5261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5262 {
5263 arg1 = wxString_in_helper(obj0);
5264 if (arg1 == NULL) SWIG_fail;
5265 temp1 = true;
5266 }
5267 {
5268 PyThreadState* __tstate = wxPyBeginAllowThreads();
5269 result = wxStripMenuCodes((wxString const &)*arg1);
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 {
5274 #if wxUSE_UNICODE
5275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5276 #else
5277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5278 #endif
5279 }
5280 {
5281 if (temp1)
5282 delete arg1;
5283 }
5284 return resultobj;
5285 fail:
5286 {
5287 if (temp1)
5288 delete arg1;
5289 }
5290 return NULL;
5291 }
5292
5293
5294 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5295 PyObject *resultobj = 0;
5296 wxString result;
5297
5298 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 result = wxGetEmailAddress();
5302 wxPyEndAllowThreads(__tstate);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 {
5306 #if wxUSE_UNICODE
5307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5308 #else
5309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5310 #endif
5311 }
5312 return resultobj;
5313 fail:
5314 return NULL;
5315 }
5316
5317
5318 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5319 PyObject *resultobj = 0;
5320 wxString result;
5321
5322 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5323 {
5324 PyThreadState* __tstate = wxPyBeginAllowThreads();
5325 result = wxGetHostName();
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 {
5330 #if wxUSE_UNICODE
5331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5332 #else
5333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5334 #endif
5335 }
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5343 PyObject *resultobj = 0;
5344 wxString result;
5345
5346 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5347 {
5348 PyThreadState* __tstate = wxPyBeginAllowThreads();
5349 result = wxGetFullHostName();
5350 wxPyEndAllowThreads(__tstate);
5351 if (PyErr_Occurred()) SWIG_fail;
5352 }
5353 {
5354 #if wxUSE_UNICODE
5355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5356 #else
5357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5358 #endif
5359 }
5360 return resultobj;
5361 fail:
5362 return NULL;
5363 }
5364
5365
5366 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5367 PyObject *resultobj = 0;
5368 wxString result;
5369
5370 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5371 {
5372 PyThreadState* __tstate = wxPyBeginAllowThreads();
5373 result = wxGetUserId();
5374 wxPyEndAllowThreads(__tstate);
5375 if (PyErr_Occurred()) SWIG_fail;
5376 }
5377 {
5378 #if wxUSE_UNICODE
5379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5380 #else
5381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5382 #endif
5383 }
5384 return resultobj;
5385 fail:
5386 return NULL;
5387 }
5388
5389
5390 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5391 PyObject *resultobj = 0;
5392 wxString result;
5393
5394 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5395 {
5396 PyThreadState* __tstate = wxPyBeginAllowThreads();
5397 result = wxGetUserName();
5398 wxPyEndAllowThreads(__tstate);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 {
5402 #if wxUSE_UNICODE
5403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5404 #else
5405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5406 #endif
5407 }
5408 return resultobj;
5409 fail:
5410 return NULL;
5411 }
5412
5413
5414 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5415 PyObject *resultobj = 0;
5416 wxString result;
5417
5418 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5419 {
5420 PyThreadState* __tstate = wxPyBeginAllowThreads();
5421 result = wxGetHomeDir();
5422 wxPyEndAllowThreads(__tstate);
5423 if (PyErr_Occurred()) SWIG_fail;
5424 }
5425 {
5426 #if wxUSE_UNICODE
5427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5428 #else
5429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5430 #endif
5431 }
5432 return resultobj;
5433 fail:
5434 return NULL;
5435 }
5436
5437
5438 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5439 PyObject *resultobj = 0;
5440 wxString const &arg1_defvalue = wxPyEmptyString ;
5441 wxString *arg1 = (wxString *) &arg1_defvalue ;
5442 wxString result;
5443 bool temp1 = false ;
5444 PyObject * obj0 = 0 ;
5445 char * kwnames[] = {
5446 (char *) "user", NULL
5447 };
5448
5449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5450 if (obj0) {
5451 {
5452 arg1 = wxString_in_helper(obj0);
5453 if (arg1 == NULL) SWIG_fail;
5454 temp1 = true;
5455 }
5456 }
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = wxGetUserHome((wxString const &)*arg1);
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 {
5464 #if wxUSE_UNICODE
5465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5466 #else
5467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5468 #endif
5469 }
5470 {
5471 if (temp1)
5472 delete arg1;
5473 }
5474 return resultobj;
5475 fail:
5476 {
5477 if (temp1)
5478 delete arg1;
5479 }
5480 return NULL;
5481 }
5482
5483
5484 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5485 PyObject *resultobj = 0;
5486 unsigned long result;
5487
5488 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = (unsigned long)wxGetProcessId();
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5496 return resultobj;
5497 fail:
5498 return NULL;
5499 }
5500
5501
5502 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5503 PyObject *resultobj = 0;
5504
5505 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5506 {
5507 PyThreadState* __tstate = wxPyBeginAllowThreads();
5508 wxTrap();
5509 wxPyEndAllowThreads(__tstate);
5510 if (PyErr_Occurred()) SWIG_fail;
5511 }
5512 resultobj = SWIG_Py_Void();
5513 return resultobj;
5514 fail:
5515 return NULL;
5516 }
5517
5518
5519 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5520 PyObject *resultobj = 0;
5521 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5522 wxString *arg1 = (wxString *) &arg1_defvalue ;
5523 wxString const &arg2_defvalue = wxPyEmptyString ;
5524 wxString *arg2 = (wxString *) &arg2_defvalue ;
5525 wxString const &arg3_defvalue = wxPyEmptyString ;
5526 wxString *arg3 = (wxString *) &arg3_defvalue ;
5527 wxString const &arg4_defvalue = wxPyEmptyString ;
5528 wxString *arg4 = (wxString *) &arg4_defvalue ;
5529 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5530 wxString *arg5 = (wxString *) &arg5_defvalue ;
5531 int arg6 = (int) 0 ;
5532 wxWindow *arg7 = (wxWindow *) NULL ;
5533 int arg8 = (int) -1 ;
5534 int arg9 = (int) -1 ;
5535 wxString result;
5536 bool temp1 = false ;
5537 bool temp2 = false ;
5538 bool temp3 = false ;
5539 bool temp4 = false ;
5540 bool temp5 = false ;
5541 int val6 ;
5542 int ecode6 = 0 ;
5543 void *argp7 = 0 ;
5544 int res7 = 0 ;
5545 int val8 ;
5546 int ecode8 = 0 ;
5547 int val9 ;
5548 int ecode9 = 0 ;
5549 PyObject * obj0 = 0 ;
5550 PyObject * obj1 = 0 ;
5551 PyObject * obj2 = 0 ;
5552 PyObject * obj3 = 0 ;
5553 PyObject * obj4 = 0 ;
5554 PyObject * obj5 = 0 ;
5555 PyObject * obj6 = 0 ;
5556 PyObject * obj7 = 0 ;
5557 PyObject * obj8 = 0 ;
5558 char * kwnames[] = {
5559 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5560 };
5561
5562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5563 if (obj0) {
5564 {
5565 arg1 = wxString_in_helper(obj0);
5566 if (arg1 == NULL) SWIG_fail;
5567 temp1 = true;
5568 }
5569 }
5570 if (obj1) {
5571 {
5572 arg2 = wxString_in_helper(obj1);
5573 if (arg2 == NULL) SWIG_fail;
5574 temp2 = true;
5575 }
5576 }
5577 if (obj2) {
5578 {
5579 arg3 = wxString_in_helper(obj2);
5580 if (arg3 == NULL) SWIG_fail;
5581 temp3 = true;
5582 }
5583 }
5584 if (obj3) {
5585 {
5586 arg4 = wxString_in_helper(obj3);
5587 if (arg4 == NULL) SWIG_fail;
5588 temp4 = true;
5589 }
5590 }
5591 if (obj4) {
5592 {
5593 arg5 = wxString_in_helper(obj4);
5594 if (arg5 == NULL) SWIG_fail;
5595 temp5 = true;
5596 }
5597 }
5598 if (obj5) {
5599 ecode6 = SWIG_AsVal_int(obj5, &val6);
5600 if (!SWIG_IsOK(ecode6)) {
5601 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5602 }
5603 arg6 = static_cast< int >(val6);
5604 }
5605 if (obj6) {
5606 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5607 if (!SWIG_IsOK(res7)) {
5608 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5609 }
5610 arg7 = reinterpret_cast< wxWindow * >(argp7);
5611 }
5612 if (obj7) {
5613 ecode8 = SWIG_AsVal_int(obj7, &val8);
5614 if (!SWIG_IsOK(ecode8)) {
5615 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5616 }
5617 arg8 = static_cast< int >(val8);
5618 }
5619 if (obj8) {
5620 ecode9 = SWIG_AsVal_int(obj8, &val9);
5621 if (!SWIG_IsOK(ecode9)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5623 }
5624 arg9 = static_cast< int >(val9);
5625 }
5626 {
5627 if (!wxPyCheckForApp()) SWIG_fail;
5628 PyThreadState* __tstate = wxPyBeginAllowThreads();
5629 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 {
5634 #if wxUSE_UNICODE
5635 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5636 #else
5637 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5638 #endif
5639 }
5640 {
5641 if (temp1)
5642 delete arg1;
5643 }
5644 {
5645 if (temp2)
5646 delete arg2;
5647 }
5648 {
5649 if (temp3)
5650 delete arg3;
5651 }
5652 {
5653 if (temp4)
5654 delete arg4;
5655 }
5656 {
5657 if (temp5)
5658 delete arg5;
5659 }
5660 return resultobj;
5661 fail:
5662 {
5663 if (temp1)
5664 delete arg1;
5665 }
5666 {
5667 if (temp2)
5668 delete arg2;
5669 }
5670 {
5671 if (temp3)
5672 delete arg3;
5673 }
5674 {
5675 if (temp4)
5676 delete arg4;
5677 }
5678 {
5679 if (temp5)
5680 delete arg5;
5681 }
5682 return NULL;
5683 }
5684
5685
5686 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj = 0;
5688 wxString *arg1 = 0 ;
5689 wxString *arg2 = 0 ;
5690 wxString const &arg3_defvalue = wxPyEmptyString ;
5691 wxString *arg3 = (wxString *) &arg3_defvalue ;
5692 wxWindow *arg4 = (wxWindow *) NULL ;
5693 wxString result;
5694 bool temp1 = false ;
5695 bool temp2 = false ;
5696 bool temp3 = false ;
5697 void *argp4 = 0 ;
5698 int res4 = 0 ;
5699 PyObject * obj0 = 0 ;
5700 PyObject * obj1 = 0 ;
5701 PyObject * obj2 = 0 ;
5702 PyObject * obj3 = 0 ;
5703 char * kwnames[] = {
5704 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5705 };
5706
5707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5708 {
5709 arg1 = wxString_in_helper(obj0);
5710 if (arg1 == NULL) SWIG_fail;
5711 temp1 = true;
5712 }
5713 {
5714 arg2 = wxString_in_helper(obj1);
5715 if (arg2 == NULL) SWIG_fail;
5716 temp2 = true;
5717 }
5718 if (obj2) {
5719 {
5720 arg3 = wxString_in_helper(obj2);
5721 if (arg3 == NULL) SWIG_fail;
5722 temp3 = true;
5723 }
5724 }
5725 if (obj3) {
5726 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5727 if (!SWIG_IsOK(res4)) {
5728 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5729 }
5730 arg4 = reinterpret_cast< wxWindow * >(argp4);
5731 }
5732 {
5733 if (!wxPyCheckForApp()) SWIG_fail;
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5736 wxPyEndAllowThreads(__tstate);
5737 if (PyErr_Occurred()) SWIG_fail;
5738 }
5739 {
5740 #if wxUSE_UNICODE
5741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5742 #else
5743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5744 #endif
5745 }
5746 {
5747 if (temp1)
5748 delete arg1;
5749 }
5750 {
5751 if (temp2)
5752 delete arg2;
5753 }
5754 {
5755 if (temp3)
5756 delete arg3;
5757 }
5758 return resultobj;
5759 fail:
5760 {
5761 if (temp1)
5762 delete arg1;
5763 }
5764 {
5765 if (temp2)
5766 delete arg2;
5767 }
5768 {
5769 if (temp3)
5770 delete arg3;
5771 }
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 wxString *arg1 = 0 ;
5779 wxString *arg2 = 0 ;
5780 wxString const &arg3_defvalue = wxPyEmptyString ;
5781 wxString *arg3 = (wxString *) &arg3_defvalue ;
5782 wxWindow *arg4 = (wxWindow *) NULL ;
5783 wxString result;
5784 bool temp1 = false ;
5785 bool temp2 = false ;
5786 bool temp3 = false ;
5787 void *argp4 = 0 ;
5788 int res4 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 PyObject * obj3 = 0 ;
5793 char * kwnames[] = {
5794 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5795 };
5796
5797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5798 {
5799 arg1 = wxString_in_helper(obj0);
5800 if (arg1 == NULL) SWIG_fail;
5801 temp1 = true;
5802 }
5803 {
5804 arg2 = wxString_in_helper(obj1);
5805 if (arg2 == NULL) SWIG_fail;
5806 temp2 = true;
5807 }
5808 if (obj2) {
5809 {
5810 arg3 = wxString_in_helper(obj2);
5811 if (arg3 == NULL) SWIG_fail;
5812 temp3 = true;
5813 }
5814 }
5815 if (obj3) {
5816 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5817 if (!SWIG_IsOK(res4)) {
5818 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5819 }
5820 arg4 = reinterpret_cast< wxWindow * >(argp4);
5821 }
5822 {
5823 if (!wxPyCheckForApp()) SWIG_fail;
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5826 wxPyEndAllowThreads(__tstate);
5827 if (PyErr_Occurred()) SWIG_fail;
5828 }
5829 {
5830 #if wxUSE_UNICODE
5831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5832 #else
5833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5834 #endif
5835 }
5836 {
5837 if (temp1)
5838 delete arg1;
5839 }
5840 {
5841 if (temp2)
5842 delete arg2;
5843 }
5844 {
5845 if (temp3)
5846 delete arg3;
5847 }
5848 return resultobj;
5849 fail:
5850 {
5851 if (temp1)
5852 delete arg1;
5853 }
5854 {
5855 if (temp2)
5856 delete arg2;
5857 }
5858 {
5859 if (temp3)
5860 delete arg3;
5861 }
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj = 0;
5868 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5869 wxString *arg1 = (wxString *) &arg1_defvalue ;
5870 wxString const &arg2_defvalue = wxPyEmptyString ;
5871 wxString *arg2 = (wxString *) &arg2_defvalue ;
5872 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5873 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5874 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5875 wxWindow *arg5 = (wxWindow *) NULL ;
5876 wxString result;
5877 bool temp1 = false ;
5878 bool temp2 = false ;
5879 long val3 ;
5880 int ecode3 = 0 ;
5881 wxPoint temp4 ;
5882 void *argp5 = 0 ;
5883 int res5 = 0 ;
5884 PyObject * obj0 = 0 ;
5885 PyObject * obj1 = 0 ;
5886 PyObject * obj2 = 0 ;
5887 PyObject * obj3 = 0 ;
5888 PyObject * obj4 = 0 ;
5889 char * kwnames[] = {
5890 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5891 };
5892
5893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5894 if (obj0) {
5895 {
5896 arg1 = wxString_in_helper(obj0);
5897 if (arg1 == NULL) SWIG_fail;
5898 temp1 = true;
5899 }
5900 }
5901 if (obj1) {
5902 {
5903 arg2 = wxString_in_helper(obj1);
5904 if (arg2 == NULL) SWIG_fail;
5905 temp2 = true;
5906 }
5907 }
5908 if (obj2) {
5909 ecode3 = SWIG_AsVal_long(obj2, &val3);
5910 if (!SWIG_IsOK(ecode3)) {
5911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5912 }
5913 arg3 = static_cast< long >(val3);
5914 }
5915 if (obj3) {
5916 {
5917 arg4 = &temp4;
5918 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5919 }
5920 }
5921 if (obj4) {
5922 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5923 if (!SWIG_IsOK(res5)) {
5924 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5925 }
5926 arg5 = reinterpret_cast< wxWindow * >(argp5);
5927 }
5928 {
5929 if (!wxPyCheckForApp()) SWIG_fail;
5930 PyThreadState* __tstate = wxPyBeginAllowThreads();
5931 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5932 wxPyEndAllowThreads(__tstate);
5933 if (PyErr_Occurred()) SWIG_fail;
5934 }
5935 {
5936 #if wxUSE_UNICODE
5937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5938 #else
5939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5940 #endif
5941 }
5942 {
5943 if (temp1)
5944 delete arg1;
5945 }
5946 {
5947 if (temp2)
5948 delete arg2;
5949 }
5950 return resultobj;
5951 fail:
5952 {
5953 if (temp1)
5954 delete arg1;
5955 }
5956 {
5957 if (temp2)
5958 delete arg2;
5959 }
5960 return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = 0;
5966 wxString *arg1 = 0 ;
5967 wxString const &arg2_defvalue = wxPyEmptyString ;
5968 wxString *arg2 = (wxString *) &arg2_defvalue ;
5969 wxString const &arg3_defvalue = wxPyEmptyString ;
5970 wxString *arg3 = (wxString *) &arg3_defvalue ;
5971 wxWindow *arg4 = (wxWindow *) NULL ;
5972 int arg5 = (int) -1 ;
5973 int arg6 = (int) -1 ;
5974 bool arg7 = (bool) true ;
5975 wxString result;
5976 bool temp1 = false ;
5977 bool temp2 = false ;
5978 bool temp3 = false ;
5979 void *argp4 = 0 ;
5980 int res4 = 0 ;
5981 int val5 ;
5982 int ecode5 = 0 ;
5983 int val6 ;
5984 int ecode6 = 0 ;
5985 bool val7 ;
5986 int ecode7 = 0 ;
5987 PyObject * obj0 = 0 ;
5988 PyObject * obj1 = 0 ;
5989 PyObject * obj2 = 0 ;
5990 PyObject * obj3 = 0 ;
5991 PyObject * obj4 = 0 ;
5992 PyObject * obj5 = 0 ;
5993 PyObject * obj6 = 0 ;
5994 char * kwnames[] = {
5995 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5996 };
5997
5998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5999 {
6000 arg1 = wxString_in_helper(obj0);
6001 if (arg1 == NULL) SWIG_fail;
6002 temp1 = true;
6003 }
6004 if (obj1) {
6005 {
6006 arg2 = wxString_in_helper(obj1);
6007 if (arg2 == NULL) SWIG_fail;
6008 temp2 = true;
6009 }
6010 }
6011 if (obj2) {
6012 {
6013 arg3 = wxString_in_helper(obj2);
6014 if (arg3 == NULL) SWIG_fail;
6015 temp3 = true;
6016 }
6017 }
6018 if (obj3) {
6019 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6020 if (!SWIG_IsOK(res4)) {
6021 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6022 }
6023 arg4 = reinterpret_cast< wxWindow * >(argp4);
6024 }
6025 if (obj4) {
6026 ecode5 = SWIG_AsVal_int(obj4, &val5);
6027 if (!SWIG_IsOK(ecode5)) {
6028 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6029 }
6030 arg5 = static_cast< int >(val5);
6031 }
6032 if (obj5) {
6033 ecode6 = SWIG_AsVal_int(obj5, &val6);
6034 if (!SWIG_IsOK(ecode6)) {
6035 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6036 }
6037 arg6 = static_cast< int >(val6);
6038 }
6039 if (obj6) {
6040 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6041 if (!SWIG_IsOK(ecode7)) {
6042 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6043 }
6044 arg7 = static_cast< bool >(val7);
6045 }
6046 {
6047 if (!wxPyCheckForApp()) SWIG_fail;
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 {
6054 #if wxUSE_UNICODE
6055 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6056 #else
6057 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6058 #endif
6059 }
6060 {
6061 if (temp1)
6062 delete arg1;
6063 }
6064 {
6065 if (temp2)
6066 delete arg2;
6067 }
6068 {
6069 if (temp3)
6070 delete arg3;
6071 }
6072 return resultobj;
6073 fail:
6074 {
6075 if (temp1)
6076 delete arg1;
6077 }
6078 {
6079 if (temp2)
6080 delete arg2;
6081 }
6082 {
6083 if (temp3)
6084 delete arg3;
6085 }
6086 return NULL;
6087 }
6088
6089
6090 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6091 PyObject *resultobj = 0;
6092 wxString *arg1 = 0 ;
6093 wxString const &arg2_defvalue = wxPyEmptyString ;
6094 wxString *arg2 = (wxString *) &arg2_defvalue ;
6095 wxString const &arg3_defvalue = wxPyEmptyString ;
6096 wxString *arg3 = (wxString *) &arg3_defvalue ;
6097 wxWindow *arg4 = (wxWindow *) NULL ;
6098 wxString result;
6099 bool temp1 = false ;
6100 bool temp2 = false ;
6101 bool temp3 = false ;
6102 void *argp4 = 0 ;
6103 int res4 = 0 ;
6104 PyObject * obj0 = 0 ;
6105 PyObject * obj1 = 0 ;
6106 PyObject * obj2 = 0 ;
6107 PyObject * obj3 = 0 ;
6108 char * kwnames[] = {
6109 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6110 };
6111
6112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6113 {
6114 arg1 = wxString_in_helper(obj0);
6115 if (arg1 == NULL) SWIG_fail;
6116 temp1 = true;
6117 }
6118 if (obj1) {
6119 {
6120 arg2 = wxString_in_helper(obj1);
6121 if (arg2 == NULL) SWIG_fail;
6122 temp2 = true;
6123 }
6124 }
6125 if (obj2) {
6126 {
6127 arg3 = wxString_in_helper(obj2);
6128 if (arg3 == NULL) SWIG_fail;
6129 temp3 = true;
6130 }
6131 }
6132 if (obj3) {
6133 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6134 if (!SWIG_IsOK(res4)) {
6135 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6136 }
6137 arg4 = reinterpret_cast< wxWindow * >(argp4);
6138 }
6139 {
6140 if (!wxPyCheckForApp()) SWIG_fail;
6141 PyThreadState* __tstate = wxPyBeginAllowThreads();
6142 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6143 wxPyEndAllowThreads(__tstate);
6144 if (PyErr_Occurred()) SWIG_fail;
6145 }
6146 {
6147 #if wxUSE_UNICODE
6148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6149 #else
6150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6151 #endif
6152 }
6153 {
6154 if (temp1)
6155 delete arg1;
6156 }
6157 {
6158 if (temp2)
6159 delete arg2;
6160 }
6161 {
6162 if (temp3)
6163 delete arg3;
6164 }
6165 return resultobj;
6166 fail:
6167 {
6168 if (temp1)
6169 delete arg1;
6170 }
6171 {
6172 if (temp2)
6173 delete arg2;
6174 }
6175 {
6176 if (temp3)
6177 delete arg3;
6178 }
6179 return NULL;
6180 }
6181
6182
6183 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj = 0;
6185 wxString *arg1 = 0 ;
6186 wxString *arg2 = 0 ;
6187 int arg3 ;
6188 wxString *arg4 = (wxString *) 0 ;
6189 wxWindow *arg5 = (wxWindow *) NULL ;
6190 int arg6 = (int) -1 ;
6191 int arg7 = (int) -1 ;
6192 bool arg8 = (bool) true ;
6193 int arg9 = (int) 150 ;
6194 int arg10 = (int) 200 ;
6195 wxString result;
6196 bool temp1 = false ;
6197 bool temp2 = false ;
6198 void *argp5 = 0 ;
6199 int res5 = 0 ;
6200 int val6 ;
6201 int ecode6 = 0 ;
6202 int val7 ;
6203 int ecode7 = 0 ;
6204 bool val8 ;
6205 int ecode8 = 0 ;
6206 int val9 ;
6207 int ecode9 = 0 ;
6208 int val10 ;
6209 int ecode10 = 0 ;
6210 PyObject * obj0 = 0 ;
6211 PyObject * obj1 = 0 ;
6212 PyObject * obj2 = 0 ;
6213 PyObject * obj3 = 0 ;
6214 PyObject * obj4 = 0 ;
6215 PyObject * obj5 = 0 ;
6216 PyObject * obj6 = 0 ;
6217 PyObject * obj7 = 0 ;
6218 PyObject * obj8 = 0 ;
6219 char * kwnames[] = {
6220 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6221 };
6222
6223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6224 {
6225 arg1 = wxString_in_helper(obj0);
6226 if (arg1 == NULL) SWIG_fail;
6227 temp1 = true;
6228 }
6229 {
6230 arg2 = wxString_in_helper(obj1);
6231 if (arg2 == NULL) SWIG_fail;
6232 temp2 = true;
6233 }
6234 {
6235 arg3 = PyList_Size(obj2);
6236 arg4 = wxString_LIST_helper(obj2);
6237 if (arg4 == NULL) SWIG_fail;
6238 }
6239 if (obj3) {
6240 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6241 if (!SWIG_IsOK(res5)) {
6242 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6243 }
6244 arg5 = reinterpret_cast< wxWindow * >(argp5);
6245 }
6246 if (obj4) {
6247 ecode6 = SWIG_AsVal_int(obj4, &val6);
6248 if (!SWIG_IsOK(ecode6)) {
6249 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6250 }
6251 arg6 = static_cast< int >(val6);
6252 }
6253 if (obj5) {
6254 ecode7 = SWIG_AsVal_int(obj5, &val7);
6255 if (!SWIG_IsOK(ecode7)) {
6256 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6257 }
6258 arg7 = static_cast< int >(val7);
6259 }
6260 if (obj6) {
6261 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6262 if (!SWIG_IsOK(ecode8)) {
6263 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6264 }
6265 arg8 = static_cast< bool >(val8);
6266 }
6267 if (obj7) {
6268 ecode9 = SWIG_AsVal_int(obj7, &val9);
6269 if (!SWIG_IsOK(ecode9)) {
6270 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6271 }
6272 arg9 = static_cast< int >(val9);
6273 }
6274 if (obj8) {
6275 ecode10 = SWIG_AsVal_int(obj8, &val10);
6276 if (!SWIG_IsOK(ecode10)) {
6277 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6278 }
6279 arg10 = static_cast< int >(val10);
6280 }
6281 {
6282 if (!wxPyCheckForApp()) SWIG_fail;
6283 PyThreadState* __tstate = wxPyBeginAllowThreads();
6284 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6285 wxPyEndAllowThreads(__tstate);
6286 if (PyErr_Occurred()) SWIG_fail;
6287 }
6288 {
6289 #if wxUSE_UNICODE
6290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6291 #else
6292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6293 #endif
6294 }
6295 {
6296 if (temp1)
6297 delete arg1;
6298 }
6299 {
6300 if (temp2)
6301 delete arg2;
6302 }
6303 {
6304 if (arg4) delete [] arg4;
6305 }
6306 return resultobj;
6307 fail:
6308 {
6309 if (temp1)
6310 delete arg1;
6311 }
6312 {
6313 if (temp2)
6314 delete arg2;
6315 }
6316 {
6317 if (arg4) delete [] arg4;
6318 }
6319 return NULL;
6320 }
6321
6322
6323 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6324 PyObject *resultobj = 0;
6325 wxString *arg1 = 0 ;
6326 wxString *arg2 = 0 ;
6327 int arg3 ;
6328 wxString *arg4 = (wxString *) 0 ;
6329 wxWindow *arg5 = (wxWindow *) NULL ;
6330 int arg6 = (int) -1 ;
6331 int arg7 = (int) -1 ;
6332 bool arg8 = (bool) true ;
6333 int arg9 = (int) 150 ;
6334 int arg10 = (int) 200 ;
6335 int result;
6336 bool temp1 = false ;
6337 bool temp2 = false ;
6338 void *argp5 = 0 ;
6339 int res5 = 0 ;
6340 int val6 ;
6341 int ecode6 = 0 ;
6342 int val7 ;
6343 int ecode7 = 0 ;
6344 bool val8 ;
6345 int ecode8 = 0 ;
6346 int val9 ;
6347 int ecode9 = 0 ;
6348 int val10 ;
6349 int ecode10 = 0 ;
6350 PyObject * obj0 = 0 ;
6351 PyObject * obj1 = 0 ;
6352 PyObject * obj2 = 0 ;
6353 PyObject * obj3 = 0 ;
6354 PyObject * obj4 = 0 ;
6355 PyObject * obj5 = 0 ;
6356 PyObject * obj6 = 0 ;
6357 PyObject * obj7 = 0 ;
6358 PyObject * obj8 = 0 ;
6359 char * kwnames[] = {
6360 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6361 };
6362
6363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6364 {
6365 arg1 = wxString_in_helper(obj0);
6366 if (arg1 == NULL) SWIG_fail;
6367 temp1 = true;
6368 }
6369 {
6370 arg2 = wxString_in_helper(obj1);
6371 if (arg2 == NULL) SWIG_fail;
6372 temp2 = true;
6373 }
6374 {
6375 arg3 = PyList_Size(obj2);
6376 arg4 = wxString_LIST_helper(obj2);
6377 if (arg4 == NULL) SWIG_fail;
6378 }
6379 if (obj3) {
6380 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6381 if (!SWIG_IsOK(res5)) {
6382 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6383 }
6384 arg5 = reinterpret_cast< wxWindow * >(argp5);
6385 }
6386 if (obj4) {
6387 ecode6 = SWIG_AsVal_int(obj4, &val6);
6388 if (!SWIG_IsOK(ecode6)) {
6389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6390 }
6391 arg6 = static_cast< int >(val6);
6392 }
6393 if (obj5) {
6394 ecode7 = SWIG_AsVal_int(obj5, &val7);
6395 if (!SWIG_IsOK(ecode7)) {
6396 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6397 }
6398 arg7 = static_cast< int >(val7);
6399 }
6400 if (obj6) {
6401 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6402 if (!SWIG_IsOK(ecode8)) {
6403 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6404 }
6405 arg8 = static_cast< bool >(val8);
6406 }
6407 if (obj7) {
6408 ecode9 = SWIG_AsVal_int(obj7, &val9);
6409 if (!SWIG_IsOK(ecode9)) {
6410 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6411 }
6412 arg9 = static_cast< int >(val9);
6413 }
6414 if (obj8) {
6415 ecode10 = SWIG_AsVal_int(obj8, &val10);
6416 if (!SWIG_IsOK(ecode10)) {
6417 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6418 }
6419 arg10 = static_cast< int >(val10);
6420 }
6421 {
6422 if (!wxPyCheckForApp()) SWIG_fail;
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_From_int(static_cast< int >(result));
6429 {
6430 if (temp1)
6431 delete arg1;
6432 }
6433 {
6434 if (temp2)
6435 delete arg2;
6436 }
6437 {
6438 if (arg4) delete [] arg4;
6439 }
6440 return resultobj;
6441 fail:
6442 {
6443 if (temp1)
6444 delete arg1;
6445 }
6446 {
6447 if (temp2)
6448 delete arg2;
6449 }
6450 {
6451 if (arg4) delete [] arg4;
6452 }
6453 return NULL;
6454 }
6455
6456
6457 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6458 PyObject *resultobj = 0;
6459 wxString *arg1 = 0 ;
6460 wxString const &arg2_defvalue = wxPyEmptyString ;
6461 wxString *arg2 = (wxString *) &arg2_defvalue ;
6462 int arg3 = (int) wxOK|wxCENTRE ;
6463 wxWindow *arg4 = (wxWindow *) NULL ;
6464 int arg5 = (int) -1 ;
6465 int arg6 = (int) -1 ;
6466 int result;
6467 bool temp1 = false ;
6468 bool temp2 = false ;
6469 int val3 ;
6470 int ecode3 = 0 ;
6471 void *argp4 = 0 ;
6472 int res4 = 0 ;
6473 int val5 ;
6474 int ecode5 = 0 ;
6475 int val6 ;
6476 int ecode6 = 0 ;
6477 PyObject * obj0 = 0 ;
6478 PyObject * obj1 = 0 ;
6479 PyObject * obj2 = 0 ;
6480 PyObject * obj3 = 0 ;
6481 PyObject * obj4 = 0 ;
6482 PyObject * obj5 = 0 ;
6483 char * kwnames[] = {
6484 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6485 };
6486
6487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6488 {
6489 arg1 = wxString_in_helper(obj0);
6490 if (arg1 == NULL) SWIG_fail;
6491 temp1 = true;
6492 }
6493 if (obj1) {
6494 {
6495 arg2 = wxString_in_helper(obj1);
6496 if (arg2 == NULL) SWIG_fail;
6497 temp2 = true;
6498 }
6499 }
6500 if (obj2) {
6501 ecode3 = SWIG_AsVal_int(obj2, &val3);
6502 if (!SWIG_IsOK(ecode3)) {
6503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6504 }
6505 arg3 = static_cast< int >(val3);
6506 }
6507 if (obj3) {
6508 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6509 if (!SWIG_IsOK(res4)) {
6510 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6511 }
6512 arg4 = reinterpret_cast< wxWindow * >(argp4);
6513 }
6514 if (obj4) {
6515 ecode5 = SWIG_AsVal_int(obj4, &val5);
6516 if (!SWIG_IsOK(ecode5)) {
6517 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6518 }
6519 arg5 = static_cast< int >(val5);
6520 }
6521 if (obj5) {
6522 ecode6 = SWIG_AsVal_int(obj5, &val6);
6523 if (!SWIG_IsOK(ecode6)) {
6524 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6525 }
6526 arg6 = static_cast< int >(val6);
6527 }
6528 {
6529 if (!wxPyCheckForApp()) SWIG_fail;
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_From_int(static_cast< int >(result));
6536 {
6537 if (temp1)
6538 delete arg1;
6539 }
6540 {
6541 if (temp2)
6542 delete arg2;
6543 }
6544 return resultobj;
6545 fail:
6546 {
6547 if (temp1)
6548 delete arg1;
6549 }
6550 {
6551 if (temp2)
6552 delete arg2;
6553 }
6554 return NULL;
6555 }
6556
6557
6558 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj = 0;
6560 wxString *arg1 = 0 ;
6561 wxString *arg2 = 0 ;
6562 wxString *arg3 = 0 ;
6563 long arg4 ;
6564 long arg5 = (long) 0 ;
6565 long arg6 = (long) 100 ;
6566 wxWindow *arg7 = (wxWindow *) NULL ;
6567 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6568 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6569 long result;
6570 bool temp1 = false ;
6571 bool temp2 = false ;
6572 bool temp3 = false ;
6573 long val4 ;
6574 int ecode4 = 0 ;
6575 long val5 ;
6576 int ecode5 = 0 ;
6577 long val6 ;
6578 int ecode6 = 0 ;
6579 void *argp7 = 0 ;
6580 int res7 = 0 ;
6581 wxPoint temp8 ;
6582 PyObject * obj0 = 0 ;
6583 PyObject * obj1 = 0 ;
6584 PyObject * obj2 = 0 ;
6585 PyObject * obj3 = 0 ;
6586 PyObject * obj4 = 0 ;
6587 PyObject * obj5 = 0 ;
6588 PyObject * obj6 = 0 ;
6589 PyObject * obj7 = 0 ;
6590 char * kwnames[] = {
6591 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6592 };
6593
6594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6595 {
6596 arg1 = wxString_in_helper(obj0);
6597 if (arg1 == NULL) SWIG_fail;
6598 temp1 = true;
6599 }
6600 {
6601 arg2 = wxString_in_helper(obj1);
6602 if (arg2 == NULL) SWIG_fail;
6603 temp2 = true;
6604 }
6605 {
6606 arg3 = wxString_in_helper(obj2);
6607 if (arg3 == NULL) SWIG_fail;
6608 temp3 = true;
6609 }
6610 ecode4 = SWIG_AsVal_long(obj3, &val4);
6611 if (!SWIG_IsOK(ecode4)) {
6612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6613 }
6614 arg4 = static_cast< long >(val4);
6615 if (obj4) {
6616 ecode5 = SWIG_AsVal_long(obj4, &val5);
6617 if (!SWIG_IsOK(ecode5)) {
6618 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6619 }
6620 arg5 = static_cast< long >(val5);
6621 }
6622 if (obj5) {
6623 ecode6 = SWIG_AsVal_long(obj5, &val6);
6624 if (!SWIG_IsOK(ecode6)) {
6625 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6626 }
6627 arg6 = static_cast< long >(val6);
6628 }
6629 if (obj6) {
6630 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6631 if (!SWIG_IsOK(res7)) {
6632 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6633 }
6634 arg7 = reinterpret_cast< wxWindow * >(argp7);
6635 }
6636 if (obj7) {
6637 {
6638 arg8 = &temp8;
6639 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6640 }
6641 }
6642 {
6643 if (!wxPyCheckForApp()) SWIG_fail;
6644 PyThreadState* __tstate = wxPyBeginAllowThreads();
6645 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6646 wxPyEndAllowThreads(__tstate);
6647 if (PyErr_Occurred()) SWIG_fail;
6648 }
6649 resultobj = SWIG_From_long(static_cast< long >(result));
6650 {
6651 if (temp1)
6652 delete arg1;
6653 }
6654 {
6655 if (temp2)
6656 delete arg2;
6657 }
6658 {
6659 if (temp3)
6660 delete arg3;
6661 }
6662 return resultobj;
6663 fail:
6664 {
6665 if (temp1)
6666 delete arg1;
6667 }
6668 {
6669 if (temp2)
6670 delete arg2;
6671 }
6672 {
6673 if (temp3)
6674 delete arg3;
6675 }
6676 return NULL;
6677 }
6678
6679
6680 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6681 PyObject *resultobj = 0;
6682 bool result;
6683
6684 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6685 {
6686 if (!wxPyCheckForApp()) SWIG_fail;
6687 PyThreadState* __tstate = wxPyBeginAllowThreads();
6688 result = (bool)wxColourDisplay();
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 {
6693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6694 }
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6702 PyObject *resultobj = 0;
6703 int result;
6704
6705 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6706 {
6707 if (!wxPyCheckForApp()) SWIG_fail;
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (int)wxDisplayDepth();
6710 wxPyEndAllowThreads(__tstate);
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 resultobj = SWIG_From_int(static_cast< int >(result));
6714 return resultobj;
6715 fail:
6716 return NULL;
6717 }
6718
6719
6720 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6721 PyObject *resultobj = 0;
6722 int result;
6723
6724 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6725 {
6726 if (!wxPyCheckForApp()) SWIG_fail;
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 result = (int)wxGetDisplayDepth();
6729 wxPyEndAllowThreads(__tstate);
6730 if (PyErr_Occurred()) SWIG_fail;
6731 }
6732 resultobj = SWIG_From_int(static_cast< int >(result));
6733 return resultobj;
6734 fail:
6735 return NULL;
6736 }
6737
6738
6739 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6740 PyObject *resultobj = 0;
6741 int *arg1 = (int *) 0 ;
6742 int *arg2 = (int *) 0 ;
6743 int temp1 ;
6744 int res1 = SWIG_TMPOBJ ;
6745 int temp2 ;
6746 int res2 = SWIG_TMPOBJ ;
6747
6748 arg1 = &temp1;
6749 arg2 = &temp2;
6750 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6751 {
6752 if (!wxPyCheckForApp()) SWIG_fail;
6753 PyThreadState* __tstate = wxPyBeginAllowThreads();
6754 wxDisplaySize(arg1,arg2);
6755 wxPyEndAllowThreads(__tstate);
6756 if (PyErr_Occurred()) SWIG_fail;
6757 }
6758 resultobj = SWIG_Py_Void();
6759 if (SWIG_IsTmpObj(res1)) {
6760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6761 } else {
6762 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6764 }
6765 if (SWIG_IsTmpObj(res2)) {
6766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6767 } else {
6768 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6770 }
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6778 PyObject *resultobj = 0;
6779 wxSize result;
6780
6781 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6782 {
6783 if (!wxPyCheckForApp()) SWIG_fail;
6784 PyThreadState* __tstate = wxPyBeginAllowThreads();
6785 result = wxGetDisplaySize();
6786 wxPyEndAllowThreads(__tstate);
6787 if (PyErr_Occurred()) SWIG_fail;
6788 }
6789 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6790 return resultobj;
6791 fail:
6792 return NULL;
6793 }
6794
6795
6796 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6797 PyObject *resultobj = 0;
6798 int *arg1 = (int *) 0 ;
6799 int *arg2 = (int *) 0 ;
6800 int temp1 ;
6801 int res1 = SWIG_TMPOBJ ;
6802 int temp2 ;
6803 int res2 = SWIG_TMPOBJ ;
6804
6805 arg1 = &temp1;
6806 arg2 = &temp2;
6807 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6808 {
6809 if (!wxPyCheckForApp()) SWIG_fail;
6810 PyThreadState* __tstate = wxPyBeginAllowThreads();
6811 wxDisplaySizeMM(arg1,arg2);
6812 wxPyEndAllowThreads(__tstate);
6813 if (PyErr_Occurred()) SWIG_fail;
6814 }
6815 resultobj = SWIG_Py_Void();
6816 if (SWIG_IsTmpObj(res1)) {
6817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6818 } else {
6819 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6821 }
6822 if (SWIG_IsTmpObj(res2)) {
6823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6824 } else {
6825 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6827 }
6828 return resultobj;
6829 fail:
6830 return NULL;
6831 }
6832
6833
6834 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6835 PyObject *resultobj = 0;
6836 wxSize result;
6837
6838 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6839 {
6840 if (!wxPyCheckForApp()) SWIG_fail;
6841 PyThreadState* __tstate = wxPyBeginAllowThreads();
6842 result = wxGetDisplaySizeMM();
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6854 PyObject *resultobj = 0;
6855 int *arg1 = (int *) 0 ;
6856 int *arg2 = (int *) 0 ;
6857 int *arg3 = (int *) 0 ;
6858 int *arg4 = (int *) 0 ;
6859 int temp1 ;
6860 int res1 = SWIG_TMPOBJ ;
6861 int temp2 ;
6862 int res2 = SWIG_TMPOBJ ;
6863 int temp3 ;
6864 int res3 = SWIG_TMPOBJ ;
6865 int temp4 ;
6866 int res4 = SWIG_TMPOBJ ;
6867
6868 arg1 = &temp1;
6869 arg2 = &temp2;
6870 arg3 = &temp3;
6871 arg4 = &temp4;
6872 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6873 {
6874 if (!wxPyCheckForApp()) SWIG_fail;
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 resultobj = SWIG_Py_Void();
6881 if (SWIG_IsTmpObj(res1)) {
6882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6883 } else {
6884 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6886 }
6887 if (SWIG_IsTmpObj(res2)) {
6888 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6889 } else {
6890 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6892 }
6893 if (SWIG_IsTmpObj(res3)) {
6894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6895 } else {
6896 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6898 }
6899 if (SWIG_IsTmpObj(res4)) {
6900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6901 } else {
6902 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6904 }
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6912 PyObject *resultobj = 0;
6913 wxRect result;
6914
6915 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6916 {
6917 if (!wxPyCheckForApp()) SWIG_fail;
6918 PyThreadState* __tstate = wxPyBeginAllowThreads();
6919 result = wxGetClientDisplayRect();
6920 wxPyEndAllowThreads(__tstate);
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj = 0;
6932 wxCursor *arg1 = 0 ;
6933 void *argp1 = 0 ;
6934 int res1 = 0 ;
6935 PyObject * obj0 = 0 ;
6936 char * kwnames[] = {
6937 (char *) "cursor", NULL
6938 };
6939
6940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6941 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6942 if (!SWIG_IsOK(res1)) {
6943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6944 }
6945 if (!argp1) {
6946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6947 }
6948 arg1 = reinterpret_cast< wxCursor * >(argp1);
6949 {
6950 if (!wxPyCheckForApp()) SWIG_fail;
6951 PyThreadState* __tstate = wxPyBeginAllowThreads();
6952 wxSetCursor(*arg1);
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_Py_Void();
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6964 PyObject *resultobj = 0;
6965 void *result = 0 ;
6966
6967 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6968 {
6969 if (!wxPyCheckForApp()) SWIG_fail;
6970 PyThreadState* __tstate = wxPyBeginAllowThreads();
6971 result = (void *)wxGetXDisplay();
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6983 PyObject *resultobj = 0;
6984 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6985 void *argp1 = 0 ;
6986 int res1 = 0 ;
6987 PyObject * obj0 = 0 ;
6988 char * kwnames[] = {
6989 (char *) "cursor", NULL
6990 };
6991
6992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6993 if (obj0) {
6994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6995 if (!SWIG_IsOK(res1)) {
6996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6997 }
6998 arg1 = reinterpret_cast< wxCursor * >(argp1);
6999 }
7000 {
7001 if (!wxPyCheckForApp()) SWIG_fail;
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 wxBeginBusyCursor(arg1);
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 resultobj = SWIG_Py_Void();
7008 return resultobj;
7009 fail:
7010 return NULL;
7011 }
7012
7013
7014 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7015 PyObject *resultobj = 0;
7016 wxPoint result;
7017
7018 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7019 {
7020 if (!wxPyCheckForApp()) SWIG_fail;
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 result = wxGetMousePosition();
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7034 PyObject *resultobj = 0;
7035 wxWindow *result = 0 ;
7036
7037 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7038 {
7039 if (!wxPyCheckForApp()) SWIG_fail;
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 result = (wxWindow *)FindWindowAtPointer();
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 {
7046 resultobj = wxPyMake_wxObject(result, 0);
7047 }
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7055 PyObject *resultobj = 0;
7056 wxWindow *result = 0 ;
7057
7058 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7059 {
7060 if (!wxPyCheckForApp()) SWIG_fail;
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 result = (wxWindow *)wxGetActiveWindow();
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 {
7067 resultobj = wxPyMake_wxObject(result, 0);
7068 }
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7076 PyObject *resultobj = 0;
7077 wxPoint *arg1 = 0 ;
7078 wxWindow *result = 0 ;
7079 wxPoint temp1 ;
7080 PyObject * obj0 = 0 ;
7081 char * kwnames[] = {
7082 (char *) "pt", NULL
7083 };
7084
7085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7086 {
7087 arg1 = &temp1;
7088 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7089 }
7090 {
7091 if (!wxPyCheckForApp()) SWIG_fail;
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7094 wxPyEndAllowThreads(__tstate);
7095 if (PyErr_Occurred()) SWIG_fail;
7096 }
7097 {
7098 resultobj = wxPyMake_wxObject(result, 0);
7099 }
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7107 PyObject *resultobj = 0;
7108 wxPoint *arg1 = 0 ;
7109 wxWindow *result = 0 ;
7110 wxPoint temp1 ;
7111 PyObject * obj0 = 0 ;
7112 char * kwnames[] = {
7113 (char *) "pt", NULL
7114 };
7115
7116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7117 {
7118 arg1 = &temp1;
7119 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7120 }
7121 {
7122 if (!wxPyCheckForApp()) SWIG_fail;
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 {
7129 resultobj = wxPyMake_wxObject(result, 0);
7130 }
7131 return resultobj;
7132 fail:
7133 return NULL;
7134 }
7135
7136
7137 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7138 PyObject *resultobj = 0;
7139 wxWindow *arg1 = (wxWindow *) 0 ;
7140 wxWindow *result = 0 ;
7141 void *argp1 = 0 ;
7142 int res1 = 0 ;
7143 PyObject * obj0 = 0 ;
7144 char * kwnames[] = {
7145 (char *) "win", NULL
7146 };
7147
7148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7150 if (!SWIG_IsOK(res1)) {
7151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7152 }
7153 arg1 = reinterpret_cast< wxWindow * >(argp1);
7154 {
7155 if (!wxPyCheckForApp()) SWIG_fail;
7156 PyThreadState* __tstate = wxPyBeginAllowThreads();
7157 result = (wxWindow *)wxGetTopLevelParent(arg1);
7158 wxPyEndAllowThreads(__tstate);
7159 if (PyErr_Occurred()) SWIG_fail;
7160 }
7161 {
7162 resultobj = wxPyMake_wxObject(result, 0);
7163 }
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj = 0;
7172 wxString *arg1 = 0 ;
7173 bool result;
7174 bool temp1 = false ;
7175 PyObject * obj0 = 0 ;
7176 char * kwnames[] = {
7177 (char *) "url", NULL
7178 };
7179
7180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7181 {
7182 arg1 = wxString_in_helper(obj0);
7183 if (arg1 == NULL) SWIG_fail;
7184 temp1 = true;
7185 }
7186 {
7187 PyThreadState* __tstate = wxPyBeginAllowThreads();
7188 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7189 wxPyEndAllowThreads(__tstate);
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 {
7193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7194 }
7195 {
7196 if (temp1)
7197 delete arg1;
7198 }
7199 return resultobj;
7200 fail:
7201 {
7202 if (temp1)
7203 delete arg1;
7204 }
7205 return NULL;
7206 }
7207
7208
7209 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj = 0;
7211 wxKeyCode arg1 ;
7212 bool result;
7213 int val1 ;
7214 int ecode1 = 0 ;
7215 PyObject * obj0 = 0 ;
7216 char * kwnames[] = {
7217 (char *) "key", NULL
7218 };
7219
7220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7221 ecode1 = SWIG_AsVal_int(obj0, &val1);
7222 if (!SWIG_IsOK(ecode1)) {
7223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7224 }
7225 arg1 = static_cast< wxKeyCode >(val1);
7226 {
7227 if (!wxPyCheckForApp()) SWIG_fail;
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 result = (bool)wxGetKeyState(arg1);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 {
7234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7235 }
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7243 PyObject *resultobj = 0;
7244 wxMouseState *result = 0 ;
7245
7246 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7247 {
7248 PyThreadState* __tstate = wxPyBeginAllowThreads();
7249 result = (wxMouseState *)new wxMouseState();
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7261 PyObject *resultobj = 0;
7262 wxMouseState *arg1 = (wxMouseState *) 0 ;
7263 void *argp1 = 0 ;
7264 int res1 = 0 ;
7265 PyObject *swig_obj[1] ;
7266
7267 if (!args) SWIG_fail;
7268 swig_obj[0] = args;
7269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7270 if (!SWIG_IsOK(res1)) {
7271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7272 }
7273 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7274 {
7275 PyThreadState* __tstate = wxPyBeginAllowThreads();
7276 delete arg1;
7277
7278 wxPyEndAllowThreads(__tstate);
7279 if (PyErr_Occurred()) SWIG_fail;
7280 }
7281 resultobj = SWIG_Py_Void();
7282 return resultobj;
7283 fail:
7284 return NULL;
7285 }
7286
7287
7288 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7289 PyObject *resultobj = 0;
7290 wxMouseState *arg1 = (wxMouseState *) 0 ;
7291 int result;
7292 void *argp1 = 0 ;
7293 int res1 = 0 ;
7294 PyObject *swig_obj[1] ;
7295
7296 if (!args) SWIG_fail;
7297 swig_obj[0] = args;
7298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7299 if (!SWIG_IsOK(res1)) {
7300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7301 }
7302 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 result = (int)(arg1)->GetX();
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_From_int(static_cast< int >(result));
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7317 PyObject *resultobj = 0;
7318 wxMouseState *arg1 = (wxMouseState *) 0 ;
7319 int result;
7320 void *argp1 = 0 ;
7321 int res1 = 0 ;
7322 PyObject *swig_obj[1] ;
7323
7324 if (!args) SWIG_fail;
7325 swig_obj[0] = args;
7326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7327 if (!SWIG_IsOK(res1)) {
7328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7329 }
7330 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 result = (int)(arg1)->GetY();
7334 wxPyEndAllowThreads(__tstate);
7335 if (PyErr_Occurred()) SWIG_fail;
7336 }
7337 resultobj = SWIG_From_int(static_cast< int >(result));
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7345 PyObject *resultobj = 0;
7346 wxMouseState *arg1 = (wxMouseState *) 0 ;
7347 bool result;
7348 void *argp1 = 0 ;
7349 int res1 = 0 ;
7350 PyObject *swig_obj[1] ;
7351
7352 if (!args) SWIG_fail;
7353 swig_obj[0] = args;
7354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7355 if (!SWIG_IsOK(res1)) {
7356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7357 }
7358 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7359 {
7360 PyThreadState* __tstate = wxPyBeginAllowThreads();
7361 result = (bool)(arg1)->LeftDown();
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 {
7366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7367 }
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7375 PyObject *resultobj = 0;
7376 wxMouseState *arg1 = (wxMouseState *) 0 ;
7377 bool result;
7378 void *argp1 = 0 ;
7379 int res1 = 0 ;
7380 PyObject *swig_obj[1] ;
7381
7382 if (!args) SWIG_fail;
7383 swig_obj[0] = args;
7384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7387 }
7388 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7389 {
7390 PyThreadState* __tstate = wxPyBeginAllowThreads();
7391 result = (bool)(arg1)->MiddleDown();
7392 wxPyEndAllowThreads(__tstate);
7393 if (PyErr_Occurred()) SWIG_fail;
7394 }
7395 {
7396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7397 }
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7405 PyObject *resultobj = 0;
7406 wxMouseState *arg1 = (wxMouseState *) 0 ;
7407 bool result;
7408 void *argp1 = 0 ;
7409 int res1 = 0 ;
7410 PyObject *swig_obj[1] ;
7411
7412 if (!args) SWIG_fail;
7413 swig_obj[0] = args;
7414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7415 if (!SWIG_IsOK(res1)) {
7416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7417 }
7418 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 result = (bool)(arg1)->RightDown();
7422 wxPyEndAllowThreads(__tstate);
7423 if (PyErr_Occurred()) SWIG_fail;
7424 }
7425 {
7426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7427 }
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7435 PyObject *resultobj = 0;
7436 wxMouseState *arg1 = (wxMouseState *) 0 ;
7437 bool result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 PyObject *swig_obj[1] ;
7441
7442 if (!args) SWIG_fail;
7443 swig_obj[0] = args;
7444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7447 }
7448 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->ControlDown();
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 {
7456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7457 }
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7465 PyObject *resultobj = 0;
7466 wxMouseState *arg1 = (wxMouseState *) 0 ;
7467 bool result;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 PyObject *swig_obj[1] ;
7471
7472 if (!args) SWIG_fail;
7473 swig_obj[0] = args;
7474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7477 }
7478 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7479 {
7480 PyThreadState* __tstate = wxPyBeginAllowThreads();
7481 result = (bool)(arg1)->ShiftDown();
7482 wxPyEndAllowThreads(__tstate);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7495 PyObject *resultobj = 0;
7496 wxMouseState *arg1 = (wxMouseState *) 0 ;
7497 bool result;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 PyObject *swig_obj[1] ;
7501
7502 if (!args) SWIG_fail;
7503 swig_obj[0] = args;
7504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7505 if (!SWIG_IsOK(res1)) {
7506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7507 }
7508 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)(arg1)->AltDown();
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7525 PyObject *resultobj = 0;
7526 wxMouseState *arg1 = (wxMouseState *) 0 ;
7527 bool result;
7528 void *argp1 = 0 ;
7529 int res1 = 0 ;
7530 PyObject *swig_obj[1] ;
7531
7532 if (!args) SWIG_fail;
7533 swig_obj[0] = args;
7534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7537 }
7538 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)(arg1)->MetaDown();
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 {
7546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7547 }
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7555 PyObject *resultobj = 0;
7556 wxMouseState *arg1 = (wxMouseState *) 0 ;
7557 bool result;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 PyObject *swig_obj[1] ;
7561
7562 if (!args) SWIG_fail;
7563 swig_obj[0] = args;
7564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7567 }
7568 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (bool)(arg1)->CmdDown();
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 {
7576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7577 }
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj = 0;
7586 wxMouseState *arg1 = (wxMouseState *) 0 ;
7587 int arg2 ;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 int val2 ;
7591 int ecode2 = 0 ;
7592 PyObject * obj0 = 0 ;
7593 PyObject * obj1 = 0 ;
7594 char * kwnames[] = {
7595 (char *) "self",(char *) "x", NULL
7596 };
7597
7598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7600 if (!SWIG_IsOK(res1)) {
7601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7602 }
7603 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7604 ecode2 = SWIG_AsVal_int(obj1, &val2);
7605 if (!SWIG_IsOK(ecode2)) {
7606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7607 }
7608 arg2 = static_cast< int >(val2);
7609 {
7610 PyThreadState* __tstate = wxPyBeginAllowThreads();
7611 (arg1)->SetX(arg2);
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 resultobj = SWIG_Py_Void();
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxMouseState *arg1 = (wxMouseState *) 0 ;
7625 int arg2 ;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 int val2 ;
7629 int ecode2 = 0 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "y", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7640 }
7641 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7642 ecode2 = SWIG_AsVal_int(obj1, &val2);
7643 if (!SWIG_IsOK(ecode2)) {
7644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7645 }
7646 arg2 = static_cast< int >(val2);
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 (arg1)->SetY(arg2);
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 resultobj = SWIG_Py_Void();
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj = 0;
7662 wxMouseState *arg1 = (wxMouseState *) 0 ;
7663 bool arg2 ;
7664 void *argp1 = 0 ;
7665 int res1 = 0 ;
7666 bool val2 ;
7667 int ecode2 = 0 ;
7668 PyObject * obj0 = 0 ;
7669 PyObject * obj1 = 0 ;
7670 char * kwnames[] = {
7671 (char *) "self",(char *) "down", NULL
7672 };
7673
7674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7676 if (!SWIG_IsOK(res1)) {
7677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7678 }
7679 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7680 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7681 if (!SWIG_IsOK(ecode2)) {
7682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7683 }
7684 arg2 = static_cast< bool >(val2);
7685 {
7686 PyThreadState* __tstate = wxPyBeginAllowThreads();
7687 (arg1)->SetLeftDown(arg2);
7688 wxPyEndAllowThreads(__tstate);
7689 if (PyErr_Occurred()) SWIG_fail;
7690 }
7691 resultobj = SWIG_Py_Void();
7692 return resultobj;
7693 fail:
7694 return NULL;
7695 }
7696
7697
7698 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7699 PyObject *resultobj = 0;
7700 wxMouseState *arg1 = (wxMouseState *) 0 ;
7701 bool arg2 ;
7702 void *argp1 = 0 ;
7703 int res1 = 0 ;
7704 bool val2 ;
7705 int ecode2 = 0 ;
7706 PyObject * obj0 = 0 ;
7707 PyObject * obj1 = 0 ;
7708 char * kwnames[] = {
7709 (char *) "self",(char *) "down", NULL
7710 };
7711
7712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7714 if (!SWIG_IsOK(res1)) {
7715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7716 }
7717 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7718 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7719 if (!SWIG_IsOK(ecode2)) {
7720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7721 }
7722 arg2 = static_cast< bool >(val2);
7723 {
7724 PyThreadState* __tstate = wxPyBeginAllowThreads();
7725 (arg1)->SetMiddleDown(arg2);
7726 wxPyEndAllowThreads(__tstate);
7727 if (PyErr_Occurred()) SWIG_fail;
7728 }
7729 resultobj = SWIG_Py_Void();
7730 return resultobj;
7731 fail:
7732 return NULL;
7733 }
7734
7735
7736 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7737 PyObject *resultobj = 0;
7738 wxMouseState *arg1 = (wxMouseState *) 0 ;
7739 bool arg2 ;
7740 void *argp1 = 0 ;
7741 int res1 = 0 ;
7742 bool val2 ;
7743 int ecode2 = 0 ;
7744 PyObject * obj0 = 0 ;
7745 PyObject * obj1 = 0 ;
7746 char * kwnames[] = {
7747 (char *) "self",(char *) "down", NULL
7748 };
7749
7750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7752 if (!SWIG_IsOK(res1)) {
7753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7754 }
7755 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7757 if (!SWIG_IsOK(ecode2)) {
7758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7759 }
7760 arg2 = static_cast< bool >(val2);
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 (arg1)->SetRightDown(arg2);
7764 wxPyEndAllowThreads(__tstate);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 resultobj = SWIG_Py_Void();
7768 return resultobj;
7769 fail:
7770 return NULL;
7771 }
7772
7773
7774 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7775 PyObject *resultobj = 0;
7776 wxMouseState *arg1 = (wxMouseState *) 0 ;
7777 bool arg2 ;
7778 void *argp1 = 0 ;
7779 int res1 = 0 ;
7780 bool val2 ;
7781 int ecode2 = 0 ;
7782 PyObject * obj0 = 0 ;
7783 PyObject * obj1 = 0 ;
7784 char * kwnames[] = {
7785 (char *) "self",(char *) "down", NULL
7786 };
7787
7788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7790 if (!SWIG_IsOK(res1)) {
7791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7792 }
7793 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7794 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7795 if (!SWIG_IsOK(ecode2)) {
7796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7797 }
7798 arg2 = static_cast< bool >(val2);
7799 {
7800 PyThreadState* __tstate = wxPyBeginAllowThreads();
7801 (arg1)->SetControlDown(arg2);
7802 wxPyEndAllowThreads(__tstate);
7803 if (PyErr_Occurred()) SWIG_fail;
7804 }
7805 resultobj = SWIG_Py_Void();
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7813 PyObject *resultobj = 0;
7814 wxMouseState *arg1 = (wxMouseState *) 0 ;
7815 bool arg2 ;
7816 void *argp1 = 0 ;
7817 int res1 = 0 ;
7818 bool val2 ;
7819 int ecode2 = 0 ;
7820 PyObject * obj0 = 0 ;
7821 PyObject * obj1 = 0 ;
7822 char * kwnames[] = {
7823 (char *) "self",(char *) "down", NULL
7824 };
7825
7826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7828 if (!SWIG_IsOK(res1)) {
7829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7830 }
7831 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7832 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7833 if (!SWIG_IsOK(ecode2)) {
7834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7835 }
7836 arg2 = static_cast< bool >(val2);
7837 {
7838 PyThreadState* __tstate = wxPyBeginAllowThreads();
7839 (arg1)->SetShiftDown(arg2);
7840 wxPyEndAllowThreads(__tstate);
7841 if (PyErr_Occurred()) SWIG_fail;
7842 }
7843 resultobj = SWIG_Py_Void();
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj = 0;
7852 wxMouseState *arg1 = (wxMouseState *) 0 ;
7853 bool arg2 ;
7854 void *argp1 = 0 ;
7855 int res1 = 0 ;
7856 bool val2 ;
7857 int ecode2 = 0 ;
7858 PyObject * obj0 = 0 ;
7859 PyObject * obj1 = 0 ;
7860 char * kwnames[] = {
7861 (char *) "self",(char *) "down", NULL
7862 };
7863
7864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7866 if (!SWIG_IsOK(res1)) {
7867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7868 }
7869 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7870 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7871 if (!SWIG_IsOK(ecode2)) {
7872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7873 }
7874 arg2 = static_cast< bool >(val2);
7875 {
7876 PyThreadState* __tstate = wxPyBeginAllowThreads();
7877 (arg1)->SetAltDown(arg2);
7878 wxPyEndAllowThreads(__tstate);
7879 if (PyErr_Occurred()) SWIG_fail;
7880 }
7881 resultobj = SWIG_Py_Void();
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj = 0;
7890 wxMouseState *arg1 = (wxMouseState *) 0 ;
7891 bool arg2 ;
7892 void *argp1 = 0 ;
7893 int res1 = 0 ;
7894 bool val2 ;
7895 int ecode2 = 0 ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 char * kwnames[] = {
7899 (char *) "self",(char *) "down", NULL
7900 };
7901
7902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7904 if (!SWIG_IsOK(res1)) {
7905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7906 }
7907 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7908 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7909 if (!SWIG_IsOK(ecode2)) {
7910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7911 }
7912 arg2 = static_cast< bool >(val2);
7913 {
7914 PyThreadState* __tstate = wxPyBeginAllowThreads();
7915 (arg1)->SetMetaDown(arg2);
7916 wxPyEndAllowThreads(__tstate);
7917 if (PyErr_Occurred()) SWIG_fail;
7918 }
7919 resultobj = SWIG_Py_Void();
7920 return resultobj;
7921 fail:
7922 return NULL;
7923 }
7924
7925
7926 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7927 PyObject *obj;
7928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7929 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7930 return SWIG_Py_Void();
7931 }
7932
7933 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7934 return SWIG_Python_InitShadowInstance(args);
7935 }
7936
7937 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7938 PyObject *resultobj = 0;
7939 wxMouseState result;
7940
7941 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7942 {
7943 PyThreadState* __tstate = wxPyBeginAllowThreads();
7944 result = wxGetMouseState();
7945 wxPyEndAllowThreads(__tstate);
7946 if (PyErr_Occurred()) SWIG_fail;
7947 }
7948 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7956 PyObject *resultobj = 0;
7957
7958 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7959 {
7960 if (!wxPyCheckForApp()) SWIG_fail;
7961 PyThreadState* __tstate = wxPyBeginAllowThreads();
7962 wxWakeUpMainThread();
7963 wxPyEndAllowThreads(__tstate);
7964 if (PyErr_Occurred()) SWIG_fail;
7965 }
7966 resultobj = SWIG_Py_Void();
7967 return resultobj;
7968 fail:
7969 return NULL;
7970 }
7971
7972
7973 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7974 PyObject *resultobj = 0;
7975
7976 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7977 {
7978 if (!wxPyCheckForApp()) SWIG_fail;
7979 PyThreadState* __tstate = wxPyBeginAllowThreads();
7980 wxMutexGuiEnter();
7981 wxPyEndAllowThreads(__tstate);
7982 if (PyErr_Occurred()) SWIG_fail;
7983 }
7984 resultobj = SWIG_Py_Void();
7985 return resultobj;
7986 fail:
7987 return NULL;
7988 }
7989
7990
7991 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7992 PyObject *resultobj = 0;
7993
7994 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7995 {
7996 if (!wxPyCheckForApp()) SWIG_fail;
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 wxMutexGuiLeave();
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_Py_Void();
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8010 PyObject *resultobj = 0;
8011 wxMutexGuiLocker *result = 0 ;
8012
8013 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8014 {
8015 if (!wxPyCheckForApp()) SWIG_fail;
8016 PyThreadState* __tstate = wxPyBeginAllowThreads();
8017 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8018 wxPyEndAllowThreads(__tstate);
8019 if (PyErr_Occurred()) SWIG_fail;
8020 }
8021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8022 return resultobj;
8023 fail:
8024 return NULL;
8025 }
8026
8027
8028 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8029 PyObject *resultobj = 0;
8030 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8031 void *argp1 = 0 ;
8032 int res1 = 0 ;
8033 PyObject *swig_obj[1] ;
8034
8035 if (!args) SWIG_fail;
8036 swig_obj[0] = args;
8037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8038 if (!SWIG_IsOK(res1)) {
8039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8040 }
8041 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8042 {
8043 PyThreadState* __tstate = wxPyBeginAllowThreads();
8044 delete arg1;
8045
8046 wxPyEndAllowThreads(__tstate);
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_Py_Void();
8050 return resultobj;
8051 fail:
8052 return NULL;
8053 }
8054
8055
8056 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8057 PyObject *obj;
8058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8059 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8060 return SWIG_Py_Void();
8061 }
8062
8063 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8064 return SWIG_Python_InitShadowInstance(args);
8065 }
8066
8067 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8068 PyObject *resultobj = 0;
8069 bool result;
8070
8071 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 result = (bool)wxThread_IsMain();
8075 wxPyEndAllowThreads(__tstate);
8076 if (PyErr_Occurred()) SWIG_fail;
8077 }
8078 {
8079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8080 }
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8088 PyObject *resultobj = 0;
8089 wxString *arg1 = 0 ;
8090 wxToolTip *result = 0 ;
8091 bool temp1 = false ;
8092 PyObject * obj0 = 0 ;
8093 char * kwnames[] = {
8094 (char *) "tip", NULL
8095 };
8096
8097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8098 {
8099 arg1 = wxString_in_helper(obj0);
8100 if (arg1 == NULL) SWIG_fail;
8101 temp1 = true;
8102 }
8103 {
8104 if (!wxPyCheckForApp()) SWIG_fail;
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8107 wxPyEndAllowThreads(__tstate);
8108 if (PyErr_Occurred()) SWIG_fail;
8109 }
8110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8111 {
8112 if (temp1)
8113 delete arg1;
8114 }
8115 return resultobj;
8116 fail:
8117 {
8118 if (temp1)
8119 delete arg1;
8120 }
8121 return NULL;
8122 }
8123
8124
8125 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8126 PyObject *resultobj = 0;
8127 wxToolTip *arg1 = (wxToolTip *) 0 ;
8128 void *argp1 = 0 ;
8129 int res1 = 0 ;
8130 PyObject *swig_obj[1] ;
8131
8132 if (!args) SWIG_fail;
8133 swig_obj[0] = args;
8134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8135 if (!SWIG_IsOK(res1)) {
8136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8137 }
8138 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8139 {
8140 PyThreadState* __tstate = wxPyBeginAllowThreads();
8141 delete arg1;
8142
8143 wxPyEndAllowThreads(__tstate);
8144 if (PyErr_Occurred()) SWIG_fail;
8145 }
8146 resultobj = SWIG_Py_Void();
8147 return resultobj;
8148 fail:
8149 return NULL;
8150 }
8151
8152
8153 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj = 0;
8155 wxToolTip *arg1 = (wxToolTip *) 0 ;
8156 wxString *arg2 = 0 ;
8157 void *argp1 = 0 ;
8158 int res1 = 0 ;
8159 bool temp2 = false ;
8160 PyObject * obj0 = 0 ;
8161 PyObject * obj1 = 0 ;
8162 char * kwnames[] = {
8163 (char *) "self",(char *) "tip", NULL
8164 };
8165
8166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8168 if (!SWIG_IsOK(res1)) {
8169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8170 }
8171 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8172 {
8173 arg2 = wxString_in_helper(obj1);
8174 if (arg2 == NULL) SWIG_fail;
8175 temp2 = true;
8176 }
8177 {
8178 PyThreadState* __tstate = wxPyBeginAllowThreads();
8179 (arg1)->SetTip((wxString const &)*arg2);
8180 wxPyEndAllowThreads(__tstate);
8181 if (PyErr_Occurred()) SWIG_fail;
8182 }
8183 resultobj = SWIG_Py_Void();
8184 {
8185 if (temp2)
8186 delete arg2;
8187 }
8188 return resultobj;
8189 fail:
8190 {
8191 if (temp2)
8192 delete arg2;
8193 }
8194 return NULL;
8195 }
8196
8197
8198 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8199 PyObject *resultobj = 0;
8200 wxToolTip *arg1 = (wxToolTip *) 0 ;
8201 wxString result;
8202 void *argp1 = 0 ;
8203 int res1 = 0 ;
8204 PyObject *swig_obj[1] ;
8205
8206 if (!args) SWIG_fail;
8207 swig_obj[0] = args;
8208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8209 if (!SWIG_IsOK(res1)) {
8210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8211 }
8212 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8213 {
8214 PyThreadState* __tstate = wxPyBeginAllowThreads();
8215 result = (arg1)->GetTip();
8216 wxPyEndAllowThreads(__tstate);
8217 if (PyErr_Occurred()) SWIG_fail;
8218 }
8219 {
8220 #if wxUSE_UNICODE
8221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8222 #else
8223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8224 #endif
8225 }
8226 return resultobj;
8227 fail:
8228 return NULL;
8229 }
8230
8231
8232 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8233 PyObject *resultobj = 0;
8234 wxToolTip *arg1 = (wxToolTip *) 0 ;
8235 wxWindow *result = 0 ;
8236 void *argp1 = 0 ;
8237 int res1 = 0 ;
8238 PyObject *swig_obj[1] ;
8239
8240 if (!args) SWIG_fail;
8241 swig_obj[0] = args;
8242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8243 if (!SWIG_IsOK(res1)) {
8244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8245 }
8246 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8247 {
8248 PyThreadState* __tstate = wxPyBeginAllowThreads();
8249 result = (wxWindow *)(arg1)->GetWindow();
8250 wxPyEndAllowThreads(__tstate);
8251 if (PyErr_Occurred()) SWIG_fail;
8252 }
8253 {
8254 resultobj = wxPyMake_wxObject(result, 0);
8255 }
8256 return resultobj;
8257 fail:
8258 return NULL;
8259 }
8260
8261
8262 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8263 PyObject *resultobj = 0;
8264 bool arg1 ;
8265 bool val1 ;
8266 int ecode1 = 0 ;
8267 PyObject * obj0 = 0 ;
8268 char * kwnames[] = {
8269 (char *) "flag", NULL
8270 };
8271
8272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8273 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8274 if (!SWIG_IsOK(ecode1)) {
8275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8276 }
8277 arg1 = static_cast< bool >(val1);
8278 {
8279 PyThreadState* __tstate = wxPyBeginAllowThreads();
8280 wxToolTip::Enable(arg1);
8281 wxPyEndAllowThreads(__tstate);
8282 if (PyErr_Occurred()) SWIG_fail;
8283 }
8284 resultobj = SWIG_Py_Void();
8285 return resultobj;
8286 fail:
8287 return NULL;
8288 }
8289
8290
8291 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8292 PyObject *resultobj = 0;
8293 long arg1 ;
8294 long val1 ;
8295 int ecode1 = 0 ;
8296 PyObject * obj0 = 0 ;
8297 char * kwnames[] = {
8298 (char *) "milliseconds", NULL
8299 };
8300
8301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8302 ecode1 = SWIG_AsVal_long(obj0, &val1);
8303 if (!SWIG_IsOK(ecode1)) {
8304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8305 }
8306 arg1 = static_cast< long >(val1);
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 wxToolTip::SetDelay(arg1);
8310 wxPyEndAllowThreads(__tstate);
8311 if (PyErr_Occurred()) SWIG_fail;
8312 }
8313 resultobj = SWIG_Py_Void();
8314 return resultobj;
8315 fail:
8316 return NULL;
8317 }
8318
8319
8320 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8321 PyObject *obj;
8322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8323 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8324 return SWIG_Py_Void();
8325 }
8326
8327 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8328 return SWIG_Python_InitShadowInstance(args);
8329 }
8330
8331 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8332 PyObject *resultobj = 0;
8333 wxWindow *arg1 = (wxWindow *) 0 ;
8334 wxSize *arg2 = 0 ;
8335 wxCaret *result = 0 ;
8336 void *argp1 = 0 ;
8337 int res1 = 0 ;
8338 wxSize temp2 ;
8339 PyObject * obj0 = 0 ;
8340 PyObject * obj1 = 0 ;
8341 char * kwnames[] = {
8342 (char *) "window",(char *) "size", NULL
8343 };
8344
8345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8347 if (!SWIG_IsOK(res1)) {
8348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8349 }
8350 arg1 = reinterpret_cast< wxWindow * >(argp1);
8351 {
8352 arg2 = &temp2;
8353 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8354 }
8355 {
8356 if (!wxPyCheckForApp()) SWIG_fail;
8357 PyThreadState* __tstate = wxPyBeginAllowThreads();
8358 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8359 wxPyEndAllowThreads(__tstate);
8360 if (PyErr_Occurred()) SWIG_fail;
8361 }
8362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8363 return resultobj;
8364 fail:
8365 return NULL;
8366 }
8367
8368
8369 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8370 PyObject *resultobj = 0;
8371 wxCaret *arg1 = (wxCaret *) 0 ;
8372 void *argp1 = 0 ;
8373 int res1 = 0 ;
8374 PyObject *swig_obj[1] ;
8375
8376 if (!args) SWIG_fail;
8377 swig_obj[0] = args;
8378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8379 if (!SWIG_IsOK(res1)) {
8380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8381 }
8382 arg1 = reinterpret_cast< wxCaret * >(argp1);
8383 {
8384 PyThreadState* __tstate = wxPyBeginAllowThreads();
8385 delete arg1;
8386
8387 wxPyEndAllowThreads(__tstate);
8388 if (PyErr_Occurred()) SWIG_fail;
8389 }
8390 resultobj = SWIG_Py_Void();
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8398 PyObject *resultobj = 0;
8399 wxCaret *arg1 = (wxCaret *) 0 ;
8400 void *argp1 = 0 ;
8401 int res1 = 0 ;
8402 PyObject *swig_obj[1] ;
8403
8404 if (!args) SWIG_fail;
8405 swig_obj[0] = args;
8406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8407 if (!SWIG_IsOK(res1)) {
8408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8409 }
8410 arg1 = reinterpret_cast< wxCaret * >(argp1);
8411 {
8412 PyThreadState* __tstate = wxPyBeginAllowThreads();
8413 wxCaret_Destroy(arg1);
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 resultobj = SWIG_Py_Void();
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8425 PyObject *resultobj = 0;
8426 wxCaret *arg1 = (wxCaret *) 0 ;
8427 bool result;
8428 void *argp1 = 0 ;
8429 int res1 = 0 ;
8430 PyObject *swig_obj[1] ;
8431
8432 if (!args) SWIG_fail;
8433 swig_obj[0] = args;
8434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8435 if (!SWIG_IsOK(res1)) {
8436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8437 }
8438 arg1 = reinterpret_cast< wxCaret * >(argp1);
8439 {
8440 PyThreadState* __tstate = wxPyBeginAllowThreads();
8441 result = (bool)(arg1)->IsOk();
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 {
8446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8447 }
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8455 PyObject *resultobj = 0;
8456 wxCaret *arg1 = (wxCaret *) 0 ;
8457 bool result;
8458 void *argp1 = 0 ;
8459 int res1 = 0 ;
8460 PyObject *swig_obj[1] ;
8461
8462 if (!args) SWIG_fail;
8463 swig_obj[0] = args;
8464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8465 if (!SWIG_IsOK(res1)) {
8466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8467 }
8468 arg1 = reinterpret_cast< wxCaret * >(argp1);
8469 {
8470 PyThreadState* __tstate = wxPyBeginAllowThreads();
8471 result = (bool)(arg1)->IsVisible();
8472 wxPyEndAllowThreads(__tstate);
8473 if (PyErr_Occurred()) SWIG_fail;
8474 }
8475 {
8476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8477 }
8478 return resultobj;
8479 fail:
8480 return NULL;
8481 }
8482
8483
8484 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8485 PyObject *resultobj = 0;
8486 wxCaret *arg1 = (wxCaret *) 0 ;
8487 wxPoint result;
8488 void *argp1 = 0 ;
8489 int res1 = 0 ;
8490 PyObject *swig_obj[1] ;
8491
8492 if (!args) SWIG_fail;
8493 swig_obj[0] = args;
8494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8495 if (!SWIG_IsOK(res1)) {
8496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8497 }
8498 arg1 = reinterpret_cast< wxCaret * >(argp1);
8499 {
8500 PyThreadState* __tstate = wxPyBeginAllowThreads();
8501 result = (arg1)->GetPosition();
8502 wxPyEndAllowThreads(__tstate);
8503 if (PyErr_Occurred()) SWIG_fail;
8504 }
8505 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8506 return resultobj;
8507 fail:
8508 return NULL;
8509 }
8510
8511
8512 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8513 PyObject *resultobj = 0;
8514 wxCaret *arg1 = (wxCaret *) 0 ;
8515 int *arg2 = (int *) 0 ;
8516 int *arg3 = (int *) 0 ;
8517 void *argp1 = 0 ;
8518 int res1 = 0 ;
8519 int temp2 ;
8520 int res2 = SWIG_TMPOBJ ;
8521 int temp3 ;
8522 int res3 = SWIG_TMPOBJ ;
8523 PyObject *swig_obj[1] ;
8524
8525 arg2 = &temp2;
8526 arg3 = &temp3;
8527 if (!args) SWIG_fail;
8528 swig_obj[0] = args;
8529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8530 if (!SWIG_IsOK(res1)) {
8531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8532 }
8533 arg1 = reinterpret_cast< wxCaret * >(argp1);
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 (arg1)->GetPosition(arg2,arg3);
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 resultobj = SWIG_Py_Void();
8541 if (SWIG_IsTmpObj(res2)) {
8542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8543 } else {
8544 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8546 }
8547 if (SWIG_IsTmpObj(res3)) {
8548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8549 } else {
8550 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8552 }
8553 return resultobj;
8554 fail:
8555 return NULL;
8556 }
8557
8558
8559 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8560 PyObject *resultobj = 0;
8561 wxCaret *arg1 = (wxCaret *) 0 ;
8562 wxSize result;
8563 void *argp1 = 0 ;
8564 int res1 = 0 ;
8565 PyObject *swig_obj[1] ;
8566
8567 if (!args) SWIG_fail;
8568 swig_obj[0] = args;
8569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8570 if (!SWIG_IsOK(res1)) {
8571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8572 }
8573 arg1 = reinterpret_cast< wxCaret * >(argp1);
8574 {
8575 PyThreadState* __tstate = wxPyBeginAllowThreads();
8576 result = (arg1)->GetSize();
8577 wxPyEndAllowThreads(__tstate);
8578 if (PyErr_Occurred()) SWIG_fail;
8579 }
8580 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8581 return resultobj;
8582 fail:
8583 return NULL;
8584 }
8585
8586
8587 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8588 PyObject *resultobj = 0;
8589 wxCaret *arg1 = (wxCaret *) 0 ;
8590 int *arg2 = (int *) 0 ;
8591 int *arg3 = (int *) 0 ;
8592 void *argp1 = 0 ;
8593 int res1 = 0 ;
8594 int temp2 ;
8595 int res2 = SWIG_TMPOBJ ;
8596 int temp3 ;
8597 int res3 = SWIG_TMPOBJ ;
8598 PyObject *swig_obj[1] ;
8599
8600 arg2 = &temp2;
8601 arg3 = &temp3;
8602 if (!args) SWIG_fail;
8603 swig_obj[0] = args;
8604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8605 if (!SWIG_IsOK(res1)) {
8606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8607 }
8608 arg1 = reinterpret_cast< wxCaret * >(argp1);
8609 {
8610 PyThreadState* __tstate = wxPyBeginAllowThreads();
8611 (arg1)->GetSize(arg2,arg3);
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 resultobj = SWIG_Py_Void();
8616 if (SWIG_IsTmpObj(res2)) {
8617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8618 } else {
8619 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8621 }
8622 if (SWIG_IsTmpObj(res3)) {
8623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8624 } else {
8625 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8627 }
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8635 PyObject *resultobj = 0;
8636 wxCaret *arg1 = (wxCaret *) 0 ;
8637 wxWindow *result = 0 ;
8638 void *argp1 = 0 ;
8639 int res1 = 0 ;
8640 PyObject *swig_obj[1] ;
8641
8642 if (!args) SWIG_fail;
8643 swig_obj[0] = args;
8644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8645 if (!SWIG_IsOK(res1)) {
8646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8647 }
8648 arg1 = reinterpret_cast< wxCaret * >(argp1);
8649 {
8650 PyThreadState* __tstate = wxPyBeginAllowThreads();
8651 result = (wxWindow *)(arg1)->GetWindow();
8652 wxPyEndAllowThreads(__tstate);
8653 if (PyErr_Occurred()) SWIG_fail;
8654 }
8655 {
8656 resultobj = wxPyMake_wxObject(result, 0);
8657 }
8658 return resultobj;
8659 fail:
8660 return NULL;
8661 }
8662
8663
8664 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8665 PyObject *resultobj = 0;
8666 wxCaret *arg1 = (wxCaret *) 0 ;
8667 int arg2 ;
8668 int arg3 ;
8669 void *argp1 = 0 ;
8670 int res1 = 0 ;
8671 int val2 ;
8672 int ecode2 = 0 ;
8673 int val3 ;
8674 int ecode3 = 0 ;
8675 PyObject * obj0 = 0 ;
8676 PyObject * obj1 = 0 ;
8677 PyObject * obj2 = 0 ;
8678 char * kwnames[] = {
8679 (char *) "self",(char *) "x",(char *) "y", NULL
8680 };
8681
8682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8684 if (!SWIG_IsOK(res1)) {
8685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8686 }
8687 arg1 = reinterpret_cast< wxCaret * >(argp1);
8688 ecode2 = SWIG_AsVal_int(obj1, &val2);
8689 if (!SWIG_IsOK(ecode2)) {
8690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8691 }
8692 arg2 = static_cast< int >(val2);
8693 ecode3 = SWIG_AsVal_int(obj2, &val3);
8694 if (!SWIG_IsOK(ecode3)) {
8695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8696 }
8697 arg3 = static_cast< int >(val3);
8698 {
8699 PyThreadState* __tstate = wxPyBeginAllowThreads();
8700 (arg1)->Move(arg2,arg3);
8701 wxPyEndAllowThreads(__tstate);
8702 if (PyErr_Occurred()) SWIG_fail;
8703 }
8704 resultobj = SWIG_Py_Void();
8705 return resultobj;
8706 fail:
8707 return NULL;
8708 }
8709
8710
8711 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8712 PyObject *resultobj = 0;
8713 wxCaret *arg1 = (wxCaret *) 0 ;
8714 wxPoint *arg2 = 0 ;
8715 void *argp1 = 0 ;
8716 int res1 = 0 ;
8717 wxPoint temp2 ;
8718 PyObject * obj0 = 0 ;
8719 PyObject * obj1 = 0 ;
8720 char * kwnames[] = {
8721 (char *) "self",(char *) "pt", NULL
8722 };
8723
8724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8726 if (!SWIG_IsOK(res1)) {
8727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8728 }
8729 arg1 = reinterpret_cast< wxCaret * >(argp1);
8730 {
8731 arg2 = &temp2;
8732 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8733 }
8734 {
8735 PyThreadState* __tstate = wxPyBeginAllowThreads();
8736 (arg1)->Move((wxPoint const &)*arg2);
8737 wxPyEndAllowThreads(__tstate);
8738 if (PyErr_Occurred()) SWIG_fail;
8739 }
8740 resultobj = SWIG_Py_Void();
8741 return resultobj;
8742 fail:
8743 return NULL;
8744 }
8745
8746
8747 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8748 PyObject *resultobj = 0;
8749 wxCaret *arg1 = (wxCaret *) 0 ;
8750 int arg2 ;
8751 int arg3 ;
8752 void *argp1 = 0 ;
8753 int res1 = 0 ;
8754 int val2 ;
8755 int ecode2 = 0 ;
8756 int val3 ;
8757 int ecode3 = 0 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 PyObject * obj2 = 0 ;
8761 char * kwnames[] = {
8762 (char *) "self",(char *) "width",(char *) "height", NULL
8763 };
8764
8765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8769 }
8770 arg1 = reinterpret_cast< wxCaret * >(argp1);
8771 ecode2 = SWIG_AsVal_int(obj1, &val2);
8772 if (!SWIG_IsOK(ecode2)) {
8773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8774 }
8775 arg2 = static_cast< int >(val2);
8776 ecode3 = SWIG_AsVal_int(obj2, &val3);
8777 if (!SWIG_IsOK(ecode3)) {
8778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8779 }
8780 arg3 = static_cast< int >(val3);
8781 {
8782 PyThreadState* __tstate = wxPyBeginAllowThreads();
8783 (arg1)->SetSize(arg2,arg3);
8784 wxPyEndAllowThreads(__tstate);
8785 if (PyErr_Occurred()) SWIG_fail;
8786 }
8787 resultobj = SWIG_Py_Void();
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj = 0;
8796 wxCaret *arg1 = (wxCaret *) 0 ;
8797 wxSize *arg2 = 0 ;
8798 void *argp1 = 0 ;
8799 int res1 = 0 ;
8800 wxSize temp2 ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "size", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8811 }
8812 arg1 = reinterpret_cast< wxCaret * >(argp1);
8813 {
8814 arg2 = &temp2;
8815 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8816 }
8817 {
8818 PyThreadState* __tstate = wxPyBeginAllowThreads();
8819 (arg1)->SetSize((wxSize const &)*arg2);
8820 wxPyEndAllowThreads(__tstate);
8821 if (PyErr_Occurred()) SWIG_fail;
8822 }
8823 resultobj = SWIG_Py_Void();
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8831 PyObject *resultobj = 0;
8832 wxCaret *arg1 = (wxCaret *) 0 ;
8833 int arg2 = (int) true ;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 int val2 ;
8837 int ecode2 = 0 ;
8838 PyObject * obj0 = 0 ;
8839 PyObject * obj1 = 0 ;
8840 char * kwnames[] = {
8841 (char *) "self",(char *) "show", NULL
8842 };
8843
8844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8846 if (!SWIG_IsOK(res1)) {
8847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8848 }
8849 arg1 = reinterpret_cast< wxCaret * >(argp1);
8850 if (obj1) {
8851 ecode2 = SWIG_AsVal_int(obj1, &val2);
8852 if (!SWIG_IsOK(ecode2)) {
8853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8854 }
8855 arg2 = static_cast< int >(val2);
8856 }
8857 {
8858 PyThreadState* __tstate = wxPyBeginAllowThreads();
8859 (arg1)->Show(arg2);
8860 wxPyEndAllowThreads(__tstate);
8861 if (PyErr_Occurred()) SWIG_fail;
8862 }
8863 resultobj = SWIG_Py_Void();
8864 return resultobj;
8865 fail:
8866 return NULL;
8867 }
8868
8869
8870 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8871 PyObject *resultobj = 0;
8872 wxCaret *arg1 = (wxCaret *) 0 ;
8873 void *argp1 = 0 ;
8874 int res1 = 0 ;
8875 PyObject *swig_obj[1] ;
8876
8877 if (!args) SWIG_fail;
8878 swig_obj[0] = args;
8879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8880 if (!SWIG_IsOK(res1)) {
8881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8882 }
8883 arg1 = reinterpret_cast< wxCaret * >(argp1);
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 (arg1)->Hide();
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 resultobj = SWIG_Py_Void();
8891 return resultobj;
8892 fail:
8893 return NULL;
8894 }
8895
8896
8897 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8898 PyObject *resultobj = 0;
8899 int result;
8900
8901 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8902 {
8903 PyThreadState* __tstate = wxPyBeginAllowThreads();
8904 result = (int)wxCaret::GetBlinkTime();
8905 wxPyEndAllowThreads(__tstate);
8906 if (PyErr_Occurred()) SWIG_fail;
8907 }
8908 resultobj = SWIG_From_int(static_cast< int >(result));
8909 return resultobj;
8910 fail:
8911 return NULL;
8912 }
8913
8914
8915 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8916 PyObject *resultobj = 0;
8917 int arg1 ;
8918 int val1 ;
8919 int ecode1 = 0 ;
8920 PyObject * obj0 = 0 ;
8921 char * kwnames[] = {
8922 (char *) "milliseconds", NULL
8923 };
8924
8925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8926 ecode1 = SWIG_AsVal_int(obj0, &val1);
8927 if (!SWIG_IsOK(ecode1)) {
8928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8929 }
8930 arg1 = static_cast< int >(val1);
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 wxCaret::SetBlinkTime(arg1);
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 resultobj = SWIG_Py_Void();
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8945 PyObject *obj;
8946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8947 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8948 return SWIG_Py_Void();
8949 }
8950
8951 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8952 return SWIG_Python_InitShadowInstance(args);
8953 }
8954
8955 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8956 PyObject *resultobj = 0;
8957 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8958 wxBusyCursor *result = 0 ;
8959 void *argp1 = 0 ;
8960 int res1 = 0 ;
8961 PyObject * obj0 = 0 ;
8962 char * kwnames[] = {
8963 (char *) "cursor", NULL
8964 };
8965
8966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8967 if (obj0) {
8968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8969 if (!SWIG_IsOK(res1)) {
8970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8971 }
8972 arg1 = reinterpret_cast< wxCursor * >(argp1);
8973 }
8974 {
8975 if (!wxPyCheckForApp()) SWIG_fail;
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8982 return resultobj;
8983 fail:
8984 return NULL;
8985 }
8986
8987
8988 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8989 PyObject *resultobj = 0;
8990 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8991 void *argp1 = 0 ;
8992 int res1 = 0 ;
8993 PyObject *swig_obj[1] ;
8994
8995 if (!args) SWIG_fail;
8996 swig_obj[0] = args;
8997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8998 if (!SWIG_IsOK(res1)) {
8999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9000 }
9001 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 delete arg1;
9005
9006 wxPyEndAllowThreads(__tstate);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 resultobj = SWIG_Py_Void();
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9017 PyObject *obj;
9018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9019 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9020 return SWIG_Py_Void();
9021 }
9022
9023 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9024 return SWIG_Python_InitShadowInstance(args);
9025 }
9026
9027 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9028 PyObject *resultobj = 0;
9029 wxWindow *arg1 = (wxWindow *) NULL ;
9030 wxWindowDisabler *result = 0 ;
9031 void *argp1 = 0 ;
9032 int res1 = 0 ;
9033 PyObject * obj0 = 0 ;
9034 char * kwnames[] = {
9035 (char *) "winToSkip", NULL
9036 };
9037
9038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9039 if (obj0) {
9040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9041 if (!SWIG_IsOK(res1)) {
9042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9043 }
9044 arg1 = reinterpret_cast< wxWindow * >(argp1);
9045 }
9046 {
9047 if (!wxPyCheckForApp()) SWIG_fail;
9048 PyThreadState* __tstate = wxPyBeginAllowThreads();
9049 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9061 PyObject *resultobj = 0;
9062 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9063 void *argp1 = 0 ;
9064 int res1 = 0 ;
9065 PyObject *swig_obj[1] ;
9066
9067 if (!args) SWIG_fail;
9068 swig_obj[0] = args;
9069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9070 if (!SWIG_IsOK(res1)) {
9071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9072 }
9073 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 delete arg1;
9077
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 resultobj = SWIG_Py_Void();
9082 return resultobj;
9083 fail:
9084 return NULL;
9085 }
9086
9087
9088 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9089 PyObject *obj;
9090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9091 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9092 return SWIG_Py_Void();
9093 }
9094
9095 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9096 return SWIG_Python_InitShadowInstance(args);
9097 }
9098
9099 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9100 PyObject *resultobj = 0;
9101 wxString *arg1 = 0 ;
9102 wxBusyInfo *result = 0 ;
9103 bool temp1 = false ;
9104 PyObject * obj0 = 0 ;
9105 char * kwnames[] = {
9106 (char *) "message", NULL
9107 };
9108
9109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9110 {
9111 arg1 = wxString_in_helper(obj0);
9112 if (arg1 == NULL) SWIG_fail;
9113 temp1 = true;
9114 }
9115 {
9116 if (!wxPyCheckForApp()) SWIG_fail;
9117 PyThreadState* __tstate = wxPyBeginAllowThreads();
9118 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9123 {
9124 if (temp1)
9125 delete arg1;
9126 }
9127 return resultobj;
9128 fail:
9129 {
9130 if (temp1)
9131 delete arg1;
9132 }
9133 return NULL;
9134 }
9135
9136
9137 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9138 PyObject *resultobj = 0;
9139 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9140 void *argp1 = 0 ;
9141 int res1 = 0 ;
9142 PyObject *swig_obj[1] ;
9143
9144 if (!args) SWIG_fail;
9145 swig_obj[0] = args;
9146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9147 if (!SWIG_IsOK(res1)) {
9148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9149 }
9150 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9151 {
9152 PyThreadState* __tstate = wxPyBeginAllowThreads();
9153 delete arg1;
9154
9155 wxPyEndAllowThreads(__tstate);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 resultobj = SWIG_Py_Void();
9159 return resultobj;
9160 fail:
9161 return NULL;
9162 }
9163
9164
9165 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9166 PyObject *obj;
9167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9168 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9169 return SWIG_Py_Void();
9170 }
9171
9172 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9173 return SWIG_Python_InitShadowInstance(args);
9174 }
9175
9176 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9177 PyObject *resultobj = 0;
9178 wxStopWatch *result = 0 ;
9179
9180 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9181 {
9182 PyThreadState* __tstate = wxPyBeginAllowThreads();
9183 result = (wxStopWatch *)new wxStopWatch();
9184 wxPyEndAllowThreads(__tstate);
9185 if (PyErr_Occurred()) SWIG_fail;
9186 }
9187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9188 return resultobj;
9189 fail:
9190 return NULL;
9191 }
9192
9193
9194 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9195 PyObject *resultobj = 0;
9196 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9197 long arg2 = (long) 0 ;
9198 void *argp1 = 0 ;
9199 int res1 = 0 ;
9200 long val2 ;
9201 int ecode2 = 0 ;
9202 PyObject * obj0 = 0 ;
9203 PyObject * obj1 = 0 ;
9204 char * kwnames[] = {
9205 (char *) "self",(char *) "t0", NULL
9206 };
9207
9208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9210 if (!SWIG_IsOK(res1)) {
9211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9212 }
9213 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9214 if (obj1) {
9215 ecode2 = SWIG_AsVal_long(obj1, &val2);
9216 if (!SWIG_IsOK(ecode2)) {
9217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9218 }
9219 arg2 = static_cast< long >(val2);
9220 }
9221 {
9222 PyThreadState* __tstate = wxPyBeginAllowThreads();
9223 (arg1)->Start(arg2);
9224 wxPyEndAllowThreads(__tstate);
9225 if (PyErr_Occurred()) SWIG_fail;
9226 }
9227 resultobj = SWIG_Py_Void();
9228 return resultobj;
9229 fail:
9230 return NULL;
9231 }
9232
9233
9234 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9235 PyObject *resultobj = 0;
9236 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9237 void *argp1 = 0 ;
9238 int res1 = 0 ;
9239 PyObject *swig_obj[1] ;
9240
9241 if (!args) SWIG_fail;
9242 swig_obj[0] = args;
9243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9246 }
9247 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9248 {
9249 PyThreadState* __tstate = wxPyBeginAllowThreads();
9250 (arg1)->Pause();
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_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9262 PyObject *resultobj = 0;
9263 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9264 void *argp1 = 0 ;
9265 int res1 = 0 ;
9266 PyObject *swig_obj[1] ;
9267
9268 if (!args) SWIG_fail;
9269 swig_obj[0] = args;
9270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9271 if (!SWIG_IsOK(res1)) {
9272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9273 }
9274 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 (arg1)->Resume();
9278 wxPyEndAllowThreads(__tstate);
9279 if (PyErr_Occurred()) SWIG_fail;
9280 }
9281 resultobj = SWIG_Py_Void();
9282 return resultobj;
9283 fail:
9284 return NULL;
9285 }
9286
9287
9288 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9289 PyObject *resultobj = 0;
9290 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9291 long result;
9292 void *argp1 = 0 ;
9293 int res1 = 0 ;
9294 PyObject *swig_obj[1] ;
9295
9296 if (!args) SWIG_fail;
9297 swig_obj[0] = args;
9298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9299 if (!SWIG_IsOK(res1)) {
9300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9301 }
9302 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 result = (long)((wxStopWatch const *)arg1)->Time();
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 resultobj = SWIG_From_long(static_cast< long >(result));
9310 return resultobj;
9311 fail:
9312 return NULL;
9313 }
9314
9315
9316 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9317 PyObject *obj;
9318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9319 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9320 return SWIG_Py_Void();
9321 }
9322
9323 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9324 return SWIG_Python_InitShadowInstance(args);
9325 }
9326
9327 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9328 PyObject *resultobj = 0;
9329 int arg1 = (int) 9 ;
9330 int arg2 = (int) wxID_FILE1 ;
9331 wxFileHistory *result = 0 ;
9332 int val1 ;
9333 int ecode1 = 0 ;
9334 int val2 ;
9335 int ecode2 = 0 ;
9336 PyObject * obj0 = 0 ;
9337 PyObject * obj1 = 0 ;
9338 char * kwnames[] = {
9339 (char *) "maxFiles",(char *) "idBase", NULL
9340 };
9341
9342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9343 if (obj0) {
9344 ecode1 = SWIG_AsVal_int(obj0, &val1);
9345 if (!SWIG_IsOK(ecode1)) {
9346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9347 }
9348 arg1 = static_cast< int >(val1);
9349 }
9350 if (obj1) {
9351 ecode2 = SWIG_AsVal_int(obj1, &val2);
9352 if (!SWIG_IsOK(ecode2)) {
9353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9354 }
9355 arg2 = static_cast< int >(val2);
9356 }
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9364 return resultobj;
9365 fail:
9366 return NULL;
9367 }
9368
9369
9370 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9371 PyObject *resultobj = 0;
9372 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9373 void *argp1 = 0 ;
9374 int res1 = 0 ;
9375 PyObject *swig_obj[1] ;
9376
9377 if (!args) SWIG_fail;
9378 swig_obj[0] = args;
9379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9382 }
9383 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9384 {
9385 PyThreadState* __tstate = wxPyBeginAllowThreads();
9386 delete arg1;
9387
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 resultobj = SWIG_Py_Void();
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9399 PyObject *resultobj = 0;
9400 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9401 wxString *arg2 = 0 ;
9402 void *argp1 = 0 ;
9403 int res1 = 0 ;
9404 bool temp2 = false ;
9405 PyObject * obj0 = 0 ;
9406 PyObject * obj1 = 0 ;
9407 char * kwnames[] = {
9408 (char *) "self",(char *) "file", NULL
9409 };
9410
9411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9413 if (!SWIG_IsOK(res1)) {
9414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9415 }
9416 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9417 {
9418 arg2 = wxString_in_helper(obj1);
9419 if (arg2 == NULL) SWIG_fail;
9420 temp2 = true;
9421 }
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 (arg1)->AddFileToHistory((wxString const &)*arg2);
9425 wxPyEndAllowThreads(__tstate);
9426 if (PyErr_Occurred()) SWIG_fail;
9427 }
9428 resultobj = SWIG_Py_Void();
9429 {
9430 if (temp2)
9431 delete arg2;
9432 }
9433 return resultobj;
9434 fail:
9435 {
9436 if (temp2)
9437 delete arg2;
9438 }
9439 return NULL;
9440 }
9441
9442
9443 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9444 PyObject *resultobj = 0;
9445 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9446 int arg2 ;
9447 void *argp1 = 0 ;
9448 int res1 = 0 ;
9449 int val2 ;
9450 int ecode2 = 0 ;
9451 PyObject * obj0 = 0 ;
9452 PyObject * obj1 = 0 ;
9453 char * kwnames[] = {
9454 (char *) "self",(char *) "i", NULL
9455 };
9456
9457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9459 if (!SWIG_IsOK(res1)) {
9460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9461 }
9462 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9463 ecode2 = SWIG_AsVal_int(obj1, &val2);
9464 if (!SWIG_IsOK(ecode2)) {
9465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9466 }
9467 arg2 = static_cast< int >(val2);
9468 {
9469 PyThreadState* __tstate = wxPyBeginAllowThreads();
9470 (arg1)->RemoveFileFromHistory(arg2);
9471 wxPyEndAllowThreads(__tstate);
9472 if (PyErr_Occurred()) SWIG_fail;
9473 }
9474 resultobj = SWIG_Py_Void();
9475 return resultobj;
9476 fail:
9477 return NULL;
9478 }
9479
9480
9481 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9482 PyObject *resultobj = 0;
9483 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9484 int result;
9485 void *argp1 = 0 ;
9486 int res1 = 0 ;
9487 PyObject *swig_obj[1] ;
9488
9489 if (!args) SWIG_fail;
9490 swig_obj[0] = args;
9491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9492 if (!SWIG_IsOK(res1)) {
9493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9494 }
9495 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9496 {
9497 PyThreadState* __tstate = wxPyBeginAllowThreads();
9498 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9499 wxPyEndAllowThreads(__tstate);
9500 if (PyErr_Occurred()) SWIG_fail;
9501 }
9502 resultobj = SWIG_From_int(static_cast< int >(result));
9503 return resultobj;
9504 fail:
9505 return NULL;
9506 }
9507
9508
9509 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9510 PyObject *resultobj = 0;
9511 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9512 wxMenu *arg2 = (wxMenu *) 0 ;
9513 void *argp1 = 0 ;
9514 int res1 = 0 ;
9515 void *argp2 = 0 ;
9516 int res2 = 0 ;
9517 PyObject * obj0 = 0 ;
9518 PyObject * obj1 = 0 ;
9519 char * kwnames[] = {
9520 (char *) "self",(char *) "menu", NULL
9521 };
9522
9523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9525 if (!SWIG_IsOK(res1)) {
9526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9527 }
9528 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9529 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9530 if (!SWIG_IsOK(res2)) {
9531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9532 }
9533 arg2 = reinterpret_cast< wxMenu * >(argp2);
9534 {
9535 PyThreadState* __tstate = wxPyBeginAllowThreads();
9536 (arg1)->UseMenu(arg2);
9537 wxPyEndAllowThreads(__tstate);
9538 if (PyErr_Occurred()) SWIG_fail;
9539 }
9540 resultobj = SWIG_Py_Void();
9541 return resultobj;
9542 fail:
9543 return NULL;
9544 }
9545
9546
9547 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9548 PyObject *resultobj = 0;
9549 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9550 wxMenu *arg2 = (wxMenu *) 0 ;
9551 void *argp1 = 0 ;
9552 int res1 = 0 ;
9553 void *argp2 = 0 ;
9554 int res2 = 0 ;
9555 PyObject * obj0 = 0 ;
9556 PyObject * obj1 = 0 ;
9557 char * kwnames[] = {
9558 (char *) "self",(char *) "menu", NULL
9559 };
9560
9561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9563 if (!SWIG_IsOK(res1)) {
9564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9565 }
9566 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9567 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9568 if (!SWIG_IsOK(res2)) {
9569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9570 }
9571 arg2 = reinterpret_cast< wxMenu * >(argp2);
9572 {
9573 PyThreadState* __tstate = wxPyBeginAllowThreads();
9574 (arg1)->RemoveMenu(arg2);
9575 wxPyEndAllowThreads(__tstate);
9576 if (PyErr_Occurred()) SWIG_fail;
9577 }
9578 resultobj = SWIG_Py_Void();
9579 return resultobj;
9580 fail:
9581 return NULL;
9582 }
9583
9584
9585 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9586 PyObject *resultobj = 0;
9587 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9588 wxConfigBase *arg2 = 0 ;
9589 void *argp1 = 0 ;
9590 int res1 = 0 ;
9591 void *argp2 = 0 ;
9592 int res2 = 0 ;
9593 PyObject * obj0 = 0 ;
9594 PyObject * obj1 = 0 ;
9595 char * kwnames[] = {
9596 (char *) "self",(char *) "config", NULL
9597 };
9598
9599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9601 if (!SWIG_IsOK(res1)) {
9602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9603 }
9604 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9605 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9606 if (!SWIG_IsOK(res2)) {
9607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9608 }
9609 if (!argp2) {
9610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9611 }
9612 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 (arg1)->Load(*arg2);
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 resultobj = SWIG_Py_Void();
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj = 0;
9628 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9629 wxConfigBase *arg2 = 0 ;
9630 void *argp1 = 0 ;
9631 int res1 = 0 ;
9632 void *argp2 = 0 ;
9633 int res2 = 0 ;
9634 PyObject * obj0 = 0 ;
9635 PyObject * obj1 = 0 ;
9636 char * kwnames[] = {
9637 (char *) "self",(char *) "config", NULL
9638 };
9639
9640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9644 }
9645 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9647 if (!SWIG_IsOK(res2)) {
9648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9649 }
9650 if (!argp2) {
9651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9652 }
9653 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 (arg1)->Save(*arg2);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_Py_Void();
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9668 PyObject *resultobj = 0;
9669 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9679 }
9680 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 (arg1)->AddFilesToMenu();
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_Py_Void();
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj = 0;
9696 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9697 wxMenu *arg2 = (wxMenu *) 0 ;
9698 void *argp1 = 0 ;
9699 int res1 = 0 ;
9700 void *argp2 = 0 ;
9701 int res2 = 0 ;
9702 PyObject * obj0 = 0 ;
9703 PyObject * obj1 = 0 ;
9704 char * kwnames[] = {
9705 (char *) "self",(char *) "menu", NULL
9706 };
9707
9708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9710 if (!SWIG_IsOK(res1)) {
9711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9712 }
9713 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9715 if (!SWIG_IsOK(res2)) {
9716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9717 }
9718 arg2 = reinterpret_cast< wxMenu * >(argp2);
9719 {
9720 PyThreadState* __tstate = wxPyBeginAllowThreads();
9721 (arg1)->AddFilesToMenu(arg2);
9722 wxPyEndAllowThreads(__tstate);
9723 if (PyErr_Occurred()) SWIG_fail;
9724 }
9725 resultobj = SWIG_Py_Void();
9726 return resultobj;
9727 fail:
9728 return NULL;
9729 }
9730
9731
9732 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9733 PyObject *resultobj = 0;
9734 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9735 int arg2 ;
9736 wxString result;
9737 void *argp1 = 0 ;
9738 int res1 = 0 ;
9739 int val2 ;
9740 int ecode2 = 0 ;
9741 PyObject * obj0 = 0 ;
9742 PyObject * obj1 = 0 ;
9743 char * kwnames[] = {
9744 (char *) "self",(char *) "i", NULL
9745 };
9746
9747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9749 if (!SWIG_IsOK(res1)) {
9750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9751 }
9752 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9753 ecode2 = SWIG_AsVal_int(obj1, &val2);
9754 if (!SWIG_IsOK(ecode2)) {
9755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9756 }
9757 arg2 = static_cast< int >(val2);
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 {
9765 #if wxUSE_UNICODE
9766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9767 #else
9768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9769 #endif
9770 }
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9778 PyObject *resultobj = 0;
9779 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9780 int result;
9781 void *argp1 = 0 ;
9782 int res1 = 0 ;
9783 PyObject *swig_obj[1] ;
9784
9785 if (!args) SWIG_fail;
9786 swig_obj[0] = args;
9787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9790 }
9791 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9792 {
9793 PyThreadState* __tstate = wxPyBeginAllowThreads();
9794 result = (int)((wxFileHistory const *)arg1)->GetCount();
9795 wxPyEndAllowThreads(__tstate);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_From_int(static_cast< int >(result));
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9806 PyObject *obj;
9807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9808 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9809 return SWIG_Py_Void();
9810 }
9811
9812 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9813 return SWIG_Python_InitShadowInstance(args);
9814 }
9815
9816 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9817 PyObject *resultobj = 0;
9818 wxString *arg1 = 0 ;
9819 wxString const &arg2_defvalue = wxPyEmptyString ;
9820 wxString *arg2 = (wxString *) &arg2_defvalue ;
9821 wxSingleInstanceChecker *result = 0 ;
9822 bool temp1 = false ;
9823 bool temp2 = false ;
9824 PyObject * obj0 = 0 ;
9825 PyObject * obj1 = 0 ;
9826 char * kwnames[] = {
9827 (char *) "name",(char *) "path", NULL
9828 };
9829
9830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9831 {
9832 arg1 = wxString_in_helper(obj0);
9833 if (arg1 == NULL) SWIG_fail;
9834 temp1 = true;
9835 }
9836 if (obj1) {
9837 {
9838 arg2 = wxString_in_helper(obj1);
9839 if (arg2 == NULL) SWIG_fail;
9840 temp2 = true;
9841 }
9842 }
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9846 wxPyEndAllowThreads(__tstate);
9847 if (PyErr_Occurred()) SWIG_fail;
9848 }
9849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9850 {
9851 if (temp1)
9852 delete arg1;
9853 }
9854 {
9855 if (temp2)
9856 delete arg2;
9857 }
9858 return resultobj;
9859 fail:
9860 {
9861 if (temp1)
9862 delete arg1;
9863 }
9864 {
9865 if (temp2)
9866 delete arg2;
9867 }
9868 return NULL;
9869 }
9870
9871
9872 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9873 PyObject *resultobj = 0;
9874 wxSingleInstanceChecker *result = 0 ;
9875
9876 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9880 wxPyEndAllowThreads(__tstate);
9881 if (PyErr_Occurred()) SWIG_fail;
9882 }
9883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9891 PyObject *resultobj = 0;
9892 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9893 void *argp1 = 0 ;
9894 int res1 = 0 ;
9895 PyObject *swig_obj[1] ;
9896
9897 if (!args) SWIG_fail;
9898 swig_obj[0] = args;
9899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9900 if (!SWIG_IsOK(res1)) {
9901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9902 }
9903 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 delete arg1;
9907
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 resultobj = SWIG_Py_Void();
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9919 PyObject *resultobj = 0;
9920 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9921 wxString *arg2 = 0 ;
9922 wxString const &arg3_defvalue = wxPyEmptyString ;
9923 wxString *arg3 = (wxString *) &arg3_defvalue ;
9924 bool result;
9925 void *argp1 = 0 ;
9926 int res1 = 0 ;
9927 bool temp2 = false ;
9928 bool temp3 = false ;
9929 PyObject * obj0 = 0 ;
9930 PyObject * obj1 = 0 ;
9931 PyObject * obj2 = 0 ;
9932 char * kwnames[] = {
9933 (char *) "self",(char *) "name",(char *) "path", NULL
9934 };
9935
9936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9938 if (!SWIG_IsOK(res1)) {
9939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9940 }
9941 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9942 {
9943 arg2 = wxString_in_helper(obj1);
9944 if (arg2 == NULL) SWIG_fail;
9945 temp2 = true;
9946 }
9947 if (obj2) {
9948 {
9949 arg3 = wxString_in_helper(obj2);
9950 if (arg3 == NULL) SWIG_fail;
9951 temp3 = true;
9952 }
9953 }
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 {
9961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9962 }
9963 {
9964 if (temp2)
9965 delete arg2;
9966 }
9967 {
9968 if (temp3)
9969 delete arg3;
9970 }
9971 return resultobj;
9972 fail:
9973 {
9974 if (temp2)
9975 delete arg2;
9976 }
9977 {
9978 if (temp3)
9979 delete arg3;
9980 }
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9986 PyObject *resultobj = 0;
9987 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9988 bool result;
9989 void *argp1 = 0 ;
9990 int res1 = 0 ;
9991 PyObject *swig_obj[1] ;
9992
9993 if (!args) SWIG_fail;
9994 swig_obj[0] = args;
9995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9996 if (!SWIG_IsOK(res1)) {
9997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9998 }
9999 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10000 {
10001 PyThreadState* __tstate = wxPyBeginAllowThreads();
10002 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 {
10007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10008 }
10009 return resultobj;
10010 fail:
10011 return NULL;
10012 }
10013
10014
10015 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10016 PyObject *obj;
10017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10018 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10019 return SWIG_Py_Void();
10020 }
10021
10022 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10023 return SWIG_Python_InitShadowInstance(args);
10024 }
10025
10026 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10027 PyObject *resultobj = 0;
10028 wxWindow *arg1 = (wxWindow *) 0 ;
10029 wxDC *arg2 = 0 ;
10030 bool result;
10031 void *argp1 = 0 ;
10032 int res1 = 0 ;
10033 void *argp2 = 0 ;
10034 int res2 = 0 ;
10035 PyObject * obj0 = 0 ;
10036 PyObject * obj1 = 0 ;
10037 char * kwnames[] = {
10038 (char *) "window",(char *) "dc", NULL
10039 };
10040
10041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10043 if (!SWIG_IsOK(res1)) {
10044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10045 }
10046 arg1 = reinterpret_cast< wxWindow * >(argp1);
10047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10048 if (!SWIG_IsOK(res2)) {
10049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10050 }
10051 if (!argp2) {
10052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10053 }
10054 arg2 = reinterpret_cast< wxDC * >(argp2);
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 {
10062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10063 }
10064 return resultobj;
10065 fail:
10066 return NULL;
10067 }
10068
10069
10070 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10071 PyObject *resultobj = 0;
10072 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 PyObject *swig_obj[1] ;
10076
10077 if (!args) SWIG_fail;
10078 swig_obj[0] = args;
10079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10080 if (!SWIG_IsOK(res1)) {
10081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10082 }
10083 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10084 {
10085 PyThreadState* __tstate = wxPyBeginAllowThreads();
10086 delete arg1;
10087
10088 wxPyEndAllowThreads(__tstate);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 resultobj = SWIG_Py_Void();
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10099 PyObject *resultobj = 0;
10100 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10101 wxString result;
10102 void *argp1 = 0 ;
10103 int res1 = 0 ;
10104 PyObject *swig_obj[1] ;
10105
10106 if (!args) SWIG_fail;
10107 swig_obj[0] = args;
10108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10109 if (!SWIG_IsOK(res1)) {
10110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10111 }
10112 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10113 {
10114 PyThreadState* __tstate = wxPyBeginAllowThreads();
10115 result = (arg1)->GetTip();
10116 wxPyEndAllowThreads(__tstate);
10117 if (PyErr_Occurred()) SWIG_fail;
10118 }
10119 {
10120 #if wxUSE_UNICODE
10121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10122 #else
10123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10124 #endif
10125 }
10126 return resultobj;
10127 fail:
10128 return NULL;
10129 }
10130
10131
10132 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10133 PyObject *resultobj = 0;
10134 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10135 size_t result;
10136 void *argp1 = 0 ;
10137 int res1 = 0 ;
10138 PyObject *swig_obj[1] ;
10139
10140 if (!args) SWIG_fail;
10141 swig_obj[0] = args;
10142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10143 if (!SWIG_IsOK(res1)) {
10144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10145 }
10146 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 result = (size_t)(arg1)->GetCurrentTip();
10150 wxPyEndAllowThreads(__tstate);
10151 if (PyErr_Occurred()) SWIG_fail;
10152 }
10153 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10154 return resultobj;
10155 fail:
10156 return NULL;
10157 }
10158
10159
10160 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10161 PyObject *resultobj = 0;
10162 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10163 wxString *arg2 = 0 ;
10164 wxString result;
10165 void *argp1 = 0 ;
10166 int res1 = 0 ;
10167 bool temp2 = false ;
10168 PyObject * obj0 = 0 ;
10169 PyObject * obj1 = 0 ;
10170 char * kwnames[] = {
10171 (char *) "self",(char *) "tip", NULL
10172 };
10173
10174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10176 if (!SWIG_IsOK(res1)) {
10177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10178 }
10179 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10180 {
10181 arg2 = wxString_in_helper(obj1);
10182 if (arg2 == NULL) SWIG_fail;
10183 temp2 = true;
10184 }
10185 {
10186 PyThreadState* __tstate = wxPyBeginAllowThreads();
10187 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10188 wxPyEndAllowThreads(__tstate);
10189 if (PyErr_Occurred()) SWIG_fail;
10190 }
10191 {
10192 #if wxUSE_UNICODE
10193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10194 #else
10195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10196 #endif
10197 }
10198 {
10199 if (temp2)
10200 delete arg2;
10201 }
10202 return resultobj;
10203 fail:
10204 {
10205 if (temp2)
10206 delete arg2;
10207 }
10208 return NULL;
10209 }
10210
10211
10212 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10213 PyObject *obj;
10214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10215 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10216 return SWIG_Py_Void();
10217 }
10218
10219 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10220 PyObject *resultobj = 0;
10221 size_t arg1 ;
10222 wxPyTipProvider *result = 0 ;
10223 size_t val1 ;
10224 int ecode1 = 0 ;
10225 PyObject * obj0 = 0 ;
10226 char * kwnames[] = {
10227 (char *) "currentTip", NULL
10228 };
10229
10230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10231 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10232 if (!SWIG_IsOK(ecode1)) {
10233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10234 }
10235 arg1 = static_cast< size_t >(val1);
10236 {
10237 PyThreadState* __tstate = wxPyBeginAllowThreads();
10238 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10239 wxPyEndAllowThreads(__tstate);
10240 if (PyErr_Occurred()) SWIG_fail;
10241 }
10242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10243 return resultobj;
10244 fail:
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj = 0;
10251 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10252 PyObject *arg2 = (PyObject *) 0 ;
10253 PyObject *arg3 = (PyObject *) 0 ;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 PyObject * obj0 = 0 ;
10257 PyObject * obj1 = 0 ;
10258 PyObject * obj2 = 0 ;
10259 char * kwnames[] = {
10260 (char *) "self",(char *) "self",(char *) "_class", NULL
10261 };
10262
10263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10267 }
10268 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10269 arg2 = obj1;
10270 arg3 = obj2;
10271 {
10272 PyThreadState* __tstate = wxPyBeginAllowThreads();
10273 (arg1)->_setCallbackInfo(arg2,arg3);
10274 wxPyEndAllowThreads(__tstate);
10275 if (PyErr_Occurred()) SWIG_fail;
10276 }
10277 resultobj = SWIG_Py_Void();
10278 return resultobj;
10279 fail:
10280 return NULL;
10281 }
10282
10283
10284 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10285 PyObject *obj;
10286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10287 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10288 return SWIG_Py_Void();
10289 }
10290
10291 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10292 return SWIG_Python_InitShadowInstance(args);
10293 }
10294
10295 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10296 PyObject *resultobj = 0;
10297 wxWindow *arg1 = (wxWindow *) 0 ;
10298 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10299 bool arg3 = (bool) true ;
10300 bool result;
10301 void *argp1 = 0 ;
10302 int res1 = 0 ;
10303 void *argp2 = 0 ;
10304 int res2 = 0 ;
10305 bool val3 ;
10306 int ecode3 = 0 ;
10307 PyObject * obj0 = 0 ;
10308 PyObject * obj1 = 0 ;
10309 PyObject * obj2 = 0 ;
10310 char * kwnames[] = {
10311 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10312 };
10313
10314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10316 if (!SWIG_IsOK(res1)) {
10317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10318 }
10319 arg1 = reinterpret_cast< wxWindow * >(argp1);
10320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10321 if (!SWIG_IsOK(res2)) {
10322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10323 }
10324 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10325 if (obj2) {
10326 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10327 if (!SWIG_IsOK(ecode3)) {
10328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10329 }
10330 arg3 = static_cast< bool >(val3);
10331 }
10332 {
10333 if (!wxPyCheckForApp()) SWIG_fail;
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (bool)wxShowTip(arg1,arg2,arg3);
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 {
10340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10341 }
10342 return resultobj;
10343 fail:
10344 return NULL;
10345 }
10346
10347
10348 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj = 0;
10350 wxString *arg1 = 0 ;
10351 size_t arg2 ;
10352 wxTipProvider *result = 0 ;
10353 bool temp1 = false ;
10354 size_t val2 ;
10355 int ecode2 = 0 ;
10356 PyObject * obj0 = 0 ;
10357 PyObject * obj1 = 0 ;
10358 char * kwnames[] = {
10359 (char *) "filename",(char *) "currentTip", NULL
10360 };
10361
10362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10363 {
10364 arg1 = wxString_in_helper(obj0);
10365 if (arg1 == NULL) SWIG_fail;
10366 temp1 = true;
10367 }
10368 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10369 if (!SWIG_IsOK(ecode2)) {
10370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10371 }
10372 arg2 = static_cast< size_t >(val2);
10373 {
10374 if (!wxPyCheckForApp()) SWIG_fail;
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10381 {
10382 if (temp1)
10383 delete arg1;
10384 }
10385 return resultobj;
10386 fail:
10387 {
10388 if (temp1)
10389 delete arg1;
10390 }
10391 return NULL;
10392 }
10393
10394
10395 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10396 PyObject *resultobj = 0;
10397 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10398 int arg2 = (int) wxID_ANY ;
10399 wxPyTimer *result = 0 ;
10400 void *argp1 = 0 ;
10401 int res1 = 0 ;
10402 int val2 ;
10403 int ecode2 = 0 ;
10404 PyObject * obj0 = 0 ;
10405 PyObject * obj1 = 0 ;
10406 char * kwnames[] = {
10407 (char *) "owner",(char *) "id", NULL
10408 };
10409
10410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10411 if (obj0) {
10412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10413 if (!SWIG_IsOK(res1)) {
10414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10415 }
10416 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10417 }
10418 if (obj1) {
10419 ecode2 = SWIG_AsVal_int(obj1, &val2);
10420 if (!SWIG_IsOK(ecode2)) {
10421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10422 }
10423 arg2 = static_cast< int >(val2);
10424 }
10425 {
10426 if (!wxPyCheckForApp()) SWIG_fail;
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10433 return resultobj;
10434 fail:
10435 return NULL;
10436 }
10437
10438
10439 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10440 PyObject *resultobj = 0;
10441 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10442 void *argp1 = 0 ;
10443 int res1 = 0 ;
10444 PyObject *swig_obj[1] ;
10445
10446 if (!args) SWIG_fail;
10447 swig_obj[0] = args;
10448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10449 if (!SWIG_IsOK(res1)) {
10450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10451 }
10452 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 delete arg1;
10456
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 resultobj = SWIG_Py_Void();
10461 return resultobj;
10462 fail:
10463 return NULL;
10464 }
10465
10466
10467 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10468 PyObject *resultobj = 0;
10469 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10470 PyObject *arg2 = (PyObject *) 0 ;
10471 PyObject *arg3 = (PyObject *) 0 ;
10472 int arg4 = (int) 1 ;
10473 void *argp1 = 0 ;
10474 int res1 = 0 ;
10475 int val4 ;
10476 int ecode4 = 0 ;
10477 PyObject * obj0 = 0 ;
10478 PyObject * obj1 = 0 ;
10479 PyObject * obj2 = 0 ;
10480 PyObject * obj3 = 0 ;
10481 char * kwnames[] = {
10482 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10483 };
10484
10485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10487 if (!SWIG_IsOK(res1)) {
10488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10489 }
10490 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10491 arg2 = obj1;
10492 arg3 = obj2;
10493 if (obj3) {
10494 ecode4 = SWIG_AsVal_int(obj3, &val4);
10495 if (!SWIG_IsOK(ecode4)) {
10496 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10497 }
10498 arg4 = static_cast< int >(val4);
10499 }
10500 {
10501 PyThreadState* __tstate = wxPyBeginAllowThreads();
10502 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 resultobj = SWIG_Py_Void();
10507 return resultobj;
10508 fail:
10509 return NULL;
10510 }
10511
10512
10513 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10514 PyObject *resultobj = 0;
10515 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10516 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10517 int arg3 = (int) wxID_ANY ;
10518 void *argp1 = 0 ;
10519 int res1 = 0 ;
10520 void *argp2 = 0 ;
10521 int res2 = 0 ;
10522 int val3 ;
10523 int ecode3 = 0 ;
10524 PyObject * obj0 = 0 ;
10525 PyObject * obj1 = 0 ;
10526 PyObject * obj2 = 0 ;
10527 char * kwnames[] = {
10528 (char *) "self",(char *) "owner",(char *) "id", NULL
10529 };
10530
10531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10533 if (!SWIG_IsOK(res1)) {
10534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10535 }
10536 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10537 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10538 if (!SWIG_IsOK(res2)) {
10539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10540 }
10541 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10542 if (obj2) {
10543 ecode3 = SWIG_AsVal_int(obj2, &val3);
10544 if (!SWIG_IsOK(ecode3)) {
10545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10546 }
10547 arg3 = static_cast< int >(val3);
10548 }
10549 {
10550 PyThreadState* __tstate = wxPyBeginAllowThreads();
10551 (arg1)->SetOwner(arg2,arg3);
10552 wxPyEndAllowThreads(__tstate);
10553 if (PyErr_Occurred()) SWIG_fail;
10554 }
10555 resultobj = SWIG_Py_Void();
10556 return resultobj;
10557 fail:
10558 return NULL;
10559 }
10560
10561
10562 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10563 PyObject *resultobj = 0;
10564 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10565 wxEvtHandler *result = 0 ;
10566 void *argp1 = 0 ;
10567 int res1 = 0 ;
10568 PyObject *swig_obj[1] ;
10569
10570 if (!args) SWIG_fail;
10571 swig_obj[0] = args;
10572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10573 if (!SWIG_IsOK(res1)) {
10574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10575 }
10576 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10577 {
10578 PyThreadState* __tstate = wxPyBeginAllowThreads();
10579 result = (wxEvtHandler *)(arg1)->GetOwner();
10580 wxPyEndAllowThreads(__tstate);
10581 if (PyErr_Occurred()) SWIG_fail;
10582 }
10583 {
10584 resultobj = wxPyMake_wxObject(result, 0);
10585 }
10586 return resultobj;
10587 fail:
10588 return NULL;
10589 }
10590
10591
10592 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10593 PyObject *resultobj = 0;
10594 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10595 int arg2 = (int) -1 ;
10596 bool arg3 = (bool) false ;
10597 bool result;
10598 void *argp1 = 0 ;
10599 int res1 = 0 ;
10600 int val2 ;
10601 int ecode2 = 0 ;
10602 bool val3 ;
10603 int ecode3 = 0 ;
10604 PyObject * obj0 = 0 ;
10605 PyObject * obj1 = 0 ;
10606 PyObject * obj2 = 0 ;
10607 char * kwnames[] = {
10608 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10609 };
10610
10611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10613 if (!SWIG_IsOK(res1)) {
10614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10615 }
10616 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10617 if (obj1) {
10618 ecode2 = SWIG_AsVal_int(obj1, &val2);
10619 if (!SWIG_IsOK(ecode2)) {
10620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10621 }
10622 arg2 = static_cast< int >(val2);
10623 }
10624 if (obj2) {
10625 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10626 if (!SWIG_IsOK(ecode3)) {
10627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10628 }
10629 arg3 = static_cast< bool >(val3);
10630 }
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 result = (bool)(arg1)->Start(arg2,arg3);
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 {
10638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10639 }
10640 return resultobj;
10641 fail:
10642 return NULL;
10643 }
10644
10645
10646 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10647 PyObject *resultobj = 0;
10648 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10649 void *argp1 = 0 ;
10650 int res1 = 0 ;
10651 PyObject *swig_obj[1] ;
10652
10653 if (!args) SWIG_fail;
10654 swig_obj[0] = args;
10655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10656 if (!SWIG_IsOK(res1)) {
10657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10658 }
10659 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 (arg1)->Stop();
10663 wxPyEndAllowThreads(__tstate);
10664 if (PyErr_Occurred()) SWIG_fail;
10665 }
10666 resultobj = SWIG_Py_Void();
10667 return resultobj;
10668 fail:
10669 return NULL;
10670 }
10671
10672
10673 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10674 PyObject *resultobj = 0;
10675 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10676 void *argp1 = 0 ;
10677 int res1 = 0 ;
10678 PyObject *swig_obj[1] ;
10679
10680 if (!args) SWIG_fail;
10681 swig_obj[0] = args;
10682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10683 if (!SWIG_IsOK(res1)) {
10684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10685 }
10686 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10687 {
10688 PyThreadState* __tstate = wxPyBeginAllowThreads();
10689 (arg1)->Notify();
10690 wxPyEndAllowThreads(__tstate);
10691 if (PyErr_Occurred()) SWIG_fail;
10692 }
10693 resultobj = SWIG_Py_Void();
10694 return resultobj;
10695 fail:
10696 return NULL;
10697 }
10698
10699
10700 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10701 PyObject *resultobj = 0;
10702 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10703 bool result;
10704 void *argp1 = 0 ;
10705 int res1 = 0 ;
10706 PyObject *swig_obj[1] ;
10707
10708 if (!args) SWIG_fail;
10709 swig_obj[0] = args;
10710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10711 if (!SWIG_IsOK(res1)) {
10712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10713 }
10714 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 {
10722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10723 }
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10731 PyObject *resultobj = 0;
10732 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10733 int result;
10734 void *argp1 = 0 ;
10735 int res1 = 0 ;
10736 PyObject *swig_obj[1] ;
10737
10738 if (!args) SWIG_fail;
10739 swig_obj[0] = args;
10740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10741 if (!SWIG_IsOK(res1)) {
10742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10743 }
10744 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10745 {
10746 PyThreadState* __tstate = wxPyBeginAllowThreads();
10747 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10748 wxPyEndAllowThreads(__tstate);
10749 if (PyErr_Occurred()) SWIG_fail;
10750 }
10751 resultobj = SWIG_From_int(static_cast< int >(result));
10752 return resultobj;
10753 fail:
10754 return NULL;
10755 }
10756
10757
10758 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10759 PyObject *resultobj = 0;
10760 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10761 int result;
10762 void *argp1 = 0 ;
10763 int res1 = 0 ;
10764 PyObject *swig_obj[1] ;
10765
10766 if (!args) SWIG_fail;
10767 swig_obj[0] = args;
10768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10769 if (!SWIG_IsOK(res1)) {
10770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10771 }
10772 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10773 {
10774 PyThreadState* __tstate = wxPyBeginAllowThreads();
10775 result = (int)((wxPyTimer const *)arg1)->GetId();
10776 wxPyEndAllowThreads(__tstate);
10777 if (PyErr_Occurred()) SWIG_fail;
10778 }
10779 resultobj = SWIG_From_int(static_cast< int >(result));
10780 return resultobj;
10781 fail:
10782 return NULL;
10783 }
10784
10785
10786 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10787 PyObject *resultobj = 0;
10788 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10789 bool result;
10790 void *argp1 = 0 ;
10791 int res1 = 0 ;
10792 PyObject *swig_obj[1] ;
10793
10794 if (!args) SWIG_fail;
10795 swig_obj[0] = args;
10796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10797 if (!SWIG_IsOK(res1)) {
10798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10799 }
10800 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 {
10808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10809 }
10810 return resultobj;
10811 fail:
10812 return NULL;
10813 }
10814
10815
10816 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10817 PyObject *obj;
10818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10819 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10820 return SWIG_Py_Void();
10821 }
10822
10823 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10824 return SWIG_Python_InitShadowInstance(args);
10825 }
10826
10827 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 int arg1 = (int) 0 ;
10830 int arg2 = (int) 0 ;
10831 wxTimerEvent *result = 0 ;
10832 int val1 ;
10833 int ecode1 = 0 ;
10834 int val2 ;
10835 int ecode2 = 0 ;
10836 PyObject * obj0 = 0 ;
10837 PyObject * obj1 = 0 ;
10838 char * kwnames[] = {
10839 (char *) "timerid",(char *) "interval", NULL
10840 };
10841
10842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10843 if (obj0) {
10844 ecode1 = SWIG_AsVal_int(obj0, &val1);
10845 if (!SWIG_IsOK(ecode1)) {
10846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10847 }
10848 arg1 = static_cast< int >(val1);
10849 }
10850 if (obj1) {
10851 ecode2 = SWIG_AsVal_int(obj1, &val2);
10852 if (!SWIG_IsOK(ecode2)) {
10853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10854 }
10855 arg2 = static_cast< int >(val2);
10856 }
10857 {
10858 PyThreadState* __tstate = wxPyBeginAllowThreads();
10859 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10860 wxPyEndAllowThreads(__tstate);
10861 if (PyErr_Occurred()) SWIG_fail;
10862 }
10863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10864 return resultobj;
10865 fail:
10866 return NULL;
10867 }
10868
10869
10870 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10871 PyObject *resultobj = 0;
10872 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10873 int result;
10874 void *argp1 = 0 ;
10875 int res1 = 0 ;
10876 PyObject *swig_obj[1] ;
10877
10878 if (!args) SWIG_fail;
10879 swig_obj[0] = args;
10880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10881 if (!SWIG_IsOK(res1)) {
10882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10883 }
10884 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10885 {
10886 PyThreadState* __tstate = wxPyBeginAllowThreads();
10887 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10888 wxPyEndAllowThreads(__tstate);
10889 if (PyErr_Occurred()) SWIG_fail;
10890 }
10891 resultobj = SWIG_From_int(static_cast< int >(result));
10892 return resultobj;
10893 fail:
10894 return NULL;
10895 }
10896
10897
10898 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10899 PyObject *obj;
10900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10901 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10902 return SWIG_Py_Void();
10903 }
10904
10905 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10906 return SWIG_Python_InitShadowInstance(args);
10907 }
10908
10909 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10910 PyObject *resultobj = 0;
10911 wxTimer *arg1 = 0 ;
10912 wxTimerRunner *result = 0 ;
10913 void *argp1 = 0 ;
10914 int res1 = 0 ;
10915
10916 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10918 if (!SWIG_IsOK(res1)) {
10919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10920 }
10921 if (!argp1) {
10922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10923 }
10924 arg1 = reinterpret_cast< wxTimer * >(argp1);
10925 {
10926 if (!wxPyCheckForApp()) SWIG_fail;
10927 PyThreadState* __tstate = wxPyBeginAllowThreads();
10928 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10929 wxPyEndAllowThreads(__tstate);
10930 if (PyErr_Occurred()) SWIG_fail;
10931 }
10932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10940 PyObject *resultobj = 0;
10941 wxTimer *arg1 = 0 ;
10942 int arg2 ;
10943 bool arg3 = (bool) false ;
10944 wxTimerRunner *result = 0 ;
10945 void *argp1 = 0 ;
10946 int res1 = 0 ;
10947 int val2 ;
10948 int ecode2 = 0 ;
10949 bool val3 ;
10950 int ecode3 = 0 ;
10951
10952 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10954 if (!SWIG_IsOK(res1)) {
10955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10956 }
10957 if (!argp1) {
10958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10959 }
10960 arg1 = reinterpret_cast< wxTimer * >(argp1);
10961 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10962 if (!SWIG_IsOK(ecode2)) {
10963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10964 }
10965 arg2 = static_cast< int >(val2);
10966 if (swig_obj[2]) {
10967 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10968 if (!SWIG_IsOK(ecode3)) {
10969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10970 }
10971 arg3 = static_cast< bool >(val3);
10972 }
10973 {
10974 if (!wxPyCheckForApp()) SWIG_fail;
10975 PyThreadState* __tstate = wxPyBeginAllowThreads();
10976 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10977 wxPyEndAllowThreads(__tstate);
10978 if (PyErr_Occurred()) SWIG_fail;
10979 }
10980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10981 return resultobj;
10982 fail:
10983 return NULL;
10984 }
10985
10986
10987 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10988 int argc;
10989 PyObject *argv[4];
10990
10991 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10992 --argc;
10993 if (argc == 1) {
10994 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10995 }
10996 if ((argc >= 2) && (argc <= 3)) {
10997 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10998 }
10999
11000 fail:
11001 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11002 return NULL;
11003 }
11004
11005
11006 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11007 PyObject *resultobj = 0;
11008 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11009 void *argp1 = 0 ;
11010 int res1 = 0 ;
11011 PyObject *swig_obj[1] ;
11012
11013 if (!args) SWIG_fail;
11014 swig_obj[0] = args;
11015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11016 if (!SWIG_IsOK(res1)) {
11017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11018 }
11019 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11020 {
11021 PyThreadState* __tstate = wxPyBeginAllowThreads();
11022 delete arg1;
11023
11024 wxPyEndAllowThreads(__tstate);
11025 if (PyErr_Occurred()) SWIG_fail;
11026 }
11027 resultobj = SWIG_Py_Void();
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11035 PyObject *resultobj = 0;
11036 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11037 int arg2 ;
11038 bool arg3 = (bool) false ;
11039 void *argp1 = 0 ;
11040 int res1 = 0 ;
11041 int val2 ;
11042 int ecode2 = 0 ;
11043 bool val3 ;
11044 int ecode3 = 0 ;
11045 PyObject * obj0 = 0 ;
11046 PyObject * obj1 = 0 ;
11047 PyObject * obj2 = 0 ;
11048 char * kwnames[] = {
11049 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11050 };
11051
11052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11054 if (!SWIG_IsOK(res1)) {
11055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11056 }
11057 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11058 ecode2 = SWIG_AsVal_int(obj1, &val2);
11059 if (!SWIG_IsOK(ecode2)) {
11060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11061 }
11062 arg2 = static_cast< int >(val2);
11063 if (obj2) {
11064 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11065 if (!SWIG_IsOK(ecode3)) {
11066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11067 }
11068 arg3 = static_cast< bool >(val3);
11069 }
11070 {
11071 PyThreadState* __tstate = wxPyBeginAllowThreads();
11072 (arg1)->Start(arg2,arg3);
11073 wxPyEndAllowThreads(__tstate);
11074 if (PyErr_Occurred()) SWIG_fail;
11075 }
11076 resultobj = SWIG_Py_Void();
11077 return resultobj;
11078 fail:
11079 return NULL;
11080 }
11081
11082
11083 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11084 PyObject *obj;
11085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11086 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11087 return SWIG_Py_Void();
11088 }
11089
11090 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11091 return SWIG_Python_InitShadowInstance(args);
11092 }
11093
11094 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11095 PyObject *resultobj = 0;
11096 wxLog *result = 0 ;
11097
11098 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11099 {
11100 PyThreadState* __tstate = wxPyBeginAllowThreads();
11101 result = (wxLog *)new wxLog();
11102 wxPyEndAllowThreads(__tstate);
11103 if (PyErr_Occurred()) SWIG_fail;
11104 }
11105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11106 return resultobj;
11107 fail:
11108 return NULL;
11109 }
11110
11111
11112 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11113 PyObject *resultobj = 0;
11114 wxLog *arg1 = (wxLog *) 0 ;
11115 void *argp1 = 0 ;
11116 int res1 = 0 ;
11117 PyObject *swig_obj[1] ;
11118
11119 if (!args) SWIG_fail;
11120 swig_obj[0] = args;
11121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11122 if (!SWIG_IsOK(res1)) {
11123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11124 }
11125 arg1 = reinterpret_cast< wxLog * >(argp1);
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 delete arg1;
11129
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 resultobj = SWIG_Py_Void();
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 bool result;
11143
11144 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (bool)wxLog::IsEnabled();
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 {
11152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11153 }
11154 return resultobj;
11155 fail:
11156 return NULL;
11157 }
11158
11159
11160 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11161 PyObject *resultobj = 0;
11162 bool arg1 = (bool) true ;
11163 bool result;
11164 bool val1 ;
11165 int ecode1 = 0 ;
11166 PyObject * obj0 = 0 ;
11167 char * kwnames[] = {
11168 (char *) "doIt", NULL
11169 };
11170
11171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11172 if (obj0) {
11173 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11174 if (!SWIG_IsOK(ecode1)) {
11175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11176 }
11177 arg1 = static_cast< bool >(val1);
11178 }
11179 {
11180 PyThreadState* __tstate = wxPyBeginAllowThreads();
11181 result = (bool)wxLog::EnableLogging(arg1);
11182 wxPyEndAllowThreads(__tstate);
11183 if (PyErr_Occurred()) SWIG_fail;
11184 }
11185 {
11186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11187 }
11188 return resultobj;
11189 fail:
11190 return NULL;
11191 }
11192
11193
11194 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11195 PyObject *resultobj = 0;
11196 wxLogLevel arg1 ;
11197 wxChar *arg2 = (wxChar *) 0 ;
11198 time_t arg3 ;
11199 unsigned long val1 ;
11200 int ecode1 = 0 ;
11201 void *argp2 = 0 ;
11202 int res2 = 0 ;
11203 unsigned int val3 ;
11204 int ecode3 = 0 ;
11205 PyObject * obj0 = 0 ;
11206 PyObject * obj1 = 0 ;
11207 PyObject * obj2 = 0 ;
11208 char * kwnames[] = {
11209 (char *) "level",(char *) "szString",(char *) "t", NULL
11210 };
11211
11212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11213 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11214 if (!SWIG_IsOK(ecode1)) {
11215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11216 }
11217 arg1 = static_cast< wxLogLevel >(val1);
11218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11219 if (!SWIG_IsOK(res2)) {
11220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11221 }
11222 arg2 = reinterpret_cast< wxChar * >(argp2);
11223 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11224 if (!SWIG_IsOK(ecode3)) {
11225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11226 }
11227 arg3 = static_cast< time_t >(val3);
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 resultobj = SWIG_Py_Void();
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11242 PyObject *resultobj = 0;
11243 wxLog *arg1 = (wxLog *) 0 ;
11244 void *argp1 = 0 ;
11245 int res1 = 0 ;
11246 PyObject *swig_obj[1] ;
11247
11248 if (!args) SWIG_fail;
11249 swig_obj[0] = args;
11250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11251 if (!SWIG_IsOK(res1)) {
11252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11253 }
11254 arg1 = reinterpret_cast< wxLog * >(argp1);
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 (arg1)->Flush();
11258 wxPyEndAllowThreads(__tstate);
11259 if (PyErr_Occurred()) SWIG_fail;
11260 }
11261 resultobj = SWIG_Py_Void();
11262 return resultobj;
11263 fail:
11264 return NULL;
11265 }
11266
11267
11268 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11269 PyObject *resultobj = 0;
11270
11271 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11272 {
11273 PyThreadState* __tstate = wxPyBeginAllowThreads();
11274 wxLog::FlushActive();
11275 wxPyEndAllowThreads(__tstate);
11276 if (PyErr_Occurred()) SWIG_fail;
11277 }
11278 resultobj = SWIG_Py_Void();
11279 return resultobj;
11280 fail:
11281 return NULL;
11282 }
11283
11284
11285 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11286 PyObject *resultobj = 0;
11287 wxLog *result = 0 ;
11288
11289 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11290 {
11291 PyThreadState* __tstate = wxPyBeginAllowThreads();
11292 result = (wxLog *)wxLog::GetActiveTarget();
11293 wxPyEndAllowThreads(__tstate);
11294 if (PyErr_Occurred()) SWIG_fail;
11295 }
11296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11297 return resultobj;
11298 fail:
11299 return NULL;
11300 }
11301
11302
11303 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11304 PyObject *resultobj = 0;
11305 wxLog *arg1 = (wxLog *) 0 ;
11306 wxLog *result = 0 ;
11307 int res1 = 0 ;
11308 PyObject * obj0 = 0 ;
11309 char * kwnames[] = {
11310 (char *) "pLogger", NULL
11311 };
11312
11313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11314 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11315 if (!SWIG_IsOK(res1)) {
11316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11317 }
11318 {
11319 PyThreadState* __tstate = wxPyBeginAllowThreads();
11320 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11321 wxPyEndAllowThreads(__tstate);
11322 if (PyErr_Occurred()) SWIG_fail;
11323 }
11324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11325 return resultobj;
11326 fail:
11327 return NULL;
11328 }
11329
11330
11331 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11332 PyObject *resultobj = 0;
11333
11334 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11335 {
11336 PyThreadState* __tstate = wxPyBeginAllowThreads();
11337 wxLog::Suspend();
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 resultobj = SWIG_Py_Void();
11342 return resultobj;
11343 fail:
11344 return NULL;
11345 }
11346
11347
11348 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11349 PyObject *resultobj = 0;
11350
11351 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 wxLog::Resume();
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 return resultobj;
11360 fail:
11361 return NULL;
11362 }
11363
11364
11365 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11366 PyObject *resultobj = 0;
11367 bool arg1 = (bool) true ;
11368 bool val1 ;
11369 int ecode1 = 0 ;
11370 PyObject * obj0 = 0 ;
11371 char * kwnames[] = {
11372 (char *) "bVerbose", NULL
11373 };
11374
11375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11376 if (obj0) {
11377 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11378 if (!SWIG_IsOK(ecode1)) {
11379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11380 }
11381 arg1 = static_cast< bool >(val1);
11382 }
11383 {
11384 PyThreadState* __tstate = wxPyBeginAllowThreads();
11385 wxLog::SetVerbose(arg1);
11386 wxPyEndAllowThreads(__tstate);
11387 if (PyErr_Occurred()) SWIG_fail;
11388 }
11389 resultobj = SWIG_Py_Void();
11390 return resultobj;
11391 fail:
11392 return NULL;
11393 }
11394
11395
11396 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11397 PyObject *resultobj = 0;
11398 wxLogLevel arg1 ;
11399 unsigned long val1 ;
11400 int ecode1 = 0 ;
11401 PyObject * obj0 = 0 ;
11402 char * kwnames[] = {
11403 (char *) "logLevel", NULL
11404 };
11405
11406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11407 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11408 if (!SWIG_IsOK(ecode1)) {
11409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11410 }
11411 arg1 = static_cast< wxLogLevel >(val1);
11412 {
11413 PyThreadState* __tstate = wxPyBeginAllowThreads();
11414 wxLog::SetLogLevel(arg1);
11415 wxPyEndAllowThreads(__tstate);
11416 if (PyErr_Occurred()) SWIG_fail;
11417 }
11418 resultobj = SWIG_Py_Void();
11419 return resultobj;
11420 fail:
11421 return NULL;
11422 }
11423
11424
11425 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11426 PyObject *resultobj = 0;
11427
11428 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11429 {
11430 PyThreadState* __tstate = wxPyBeginAllowThreads();
11431 wxLog::DontCreateOnDemand();
11432 wxPyEndAllowThreads(__tstate);
11433 if (PyErr_Occurred()) SWIG_fail;
11434 }
11435 resultobj = SWIG_Py_Void();
11436 return resultobj;
11437 fail:
11438 return NULL;
11439 }
11440
11441
11442 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11443 PyObject *resultobj = 0;
11444 bool arg1 = (bool) true ;
11445 bool val1 ;
11446 int ecode1 = 0 ;
11447 PyObject * obj0 = 0 ;
11448 char * kwnames[] = {
11449 (char *) "bRepetCounting", NULL
11450 };
11451
11452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
11453 if (obj0) {
11454 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11455 if (!SWIG_IsOK(ecode1)) {
11456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
11457 }
11458 arg1 = static_cast< bool >(val1);
11459 }
11460 {
11461 PyThreadState* __tstate = wxPyBeginAllowThreads();
11462 wxLog::SetRepetitionCounting(arg1);
11463 wxPyEndAllowThreads(__tstate);
11464 if (PyErr_Occurred()) SWIG_fail;
11465 }
11466 resultobj = SWIG_Py_Void();
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11474 PyObject *resultobj = 0;
11475 bool result;
11476
11477 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
11478 {
11479 PyThreadState* __tstate = wxPyBeginAllowThreads();
11480 result = (bool)wxLog::GetRepetitionCounting();
11481 wxPyEndAllowThreads(__tstate);
11482 if (PyErr_Occurred()) SWIG_fail;
11483 }
11484 {
11485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11486 }
11487 return resultobj;
11488 fail:
11489 return NULL;
11490 }
11491
11492
11493 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11494 PyObject *resultobj = 0;
11495 wxTraceMask arg1 ;
11496 unsigned long val1 ;
11497 int ecode1 = 0 ;
11498 PyObject * obj0 = 0 ;
11499 char * kwnames[] = {
11500 (char *) "ulMask", NULL
11501 };
11502
11503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11504 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11505 if (!SWIG_IsOK(ecode1)) {
11506 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11507 }
11508 arg1 = static_cast< wxTraceMask >(val1);
11509 {
11510 PyThreadState* __tstate = wxPyBeginAllowThreads();
11511 wxLog::SetTraceMask(arg1);
11512 wxPyEndAllowThreads(__tstate);
11513 if (PyErr_Occurred()) SWIG_fail;
11514 }
11515 resultobj = SWIG_Py_Void();
11516 return resultobj;
11517 fail:
11518 return NULL;
11519 }
11520
11521
11522 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11523 PyObject *resultobj = 0;
11524 wxString *arg1 = 0 ;
11525 bool temp1 = false ;
11526 PyObject * obj0 = 0 ;
11527 char * kwnames[] = {
11528 (char *) "str", NULL
11529 };
11530
11531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11532 {
11533 arg1 = wxString_in_helper(obj0);
11534 if (arg1 == NULL) SWIG_fail;
11535 temp1 = true;
11536 }
11537 {
11538 PyThreadState* __tstate = wxPyBeginAllowThreads();
11539 wxLog::AddTraceMask((wxString const &)*arg1);
11540 wxPyEndAllowThreads(__tstate);
11541 if (PyErr_Occurred()) SWIG_fail;
11542 }
11543 resultobj = SWIG_Py_Void();
11544 {
11545 if (temp1)
11546 delete arg1;
11547 }
11548 return resultobj;
11549 fail:
11550 {
11551 if (temp1)
11552 delete arg1;
11553 }
11554 return NULL;
11555 }
11556
11557
11558 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11559 PyObject *resultobj = 0;
11560 wxString *arg1 = 0 ;
11561 bool temp1 = false ;
11562 PyObject * obj0 = 0 ;
11563 char * kwnames[] = {
11564 (char *) "str", NULL
11565 };
11566
11567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11568 {
11569 arg1 = wxString_in_helper(obj0);
11570 if (arg1 == NULL) SWIG_fail;
11571 temp1 = true;
11572 }
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 wxLog::RemoveTraceMask((wxString const &)*arg1);
11576 wxPyEndAllowThreads(__tstate);
11577 if (PyErr_Occurred()) SWIG_fail;
11578 }
11579 resultobj = SWIG_Py_Void();
11580 {
11581 if (temp1)
11582 delete arg1;
11583 }
11584 return resultobj;
11585 fail:
11586 {
11587 if (temp1)
11588 delete arg1;
11589 }
11590 return NULL;
11591 }
11592
11593
11594 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11595 PyObject *resultobj = 0;
11596
11597 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11598 {
11599 PyThreadState* __tstate = wxPyBeginAllowThreads();
11600 wxLog::ClearTraceMasks();
11601 wxPyEndAllowThreads(__tstate);
11602 if (PyErr_Occurred()) SWIG_fail;
11603 }
11604 resultobj = SWIG_Py_Void();
11605 return resultobj;
11606 fail:
11607 return NULL;
11608 }
11609
11610
11611 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11612 PyObject *resultobj = 0;
11613 wxArrayString *result = 0 ;
11614
11615 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 {
11619 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11620 result = (wxArrayString *) &_result_ref;
11621 }
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 {
11626 resultobj = wxArrayString2PyList_helper(*result);
11627 }
11628 return resultobj;
11629 fail:
11630 return NULL;
11631 }
11632
11633
11634 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11635 PyObject *resultobj = 0;
11636 wxChar *arg1 = (wxChar *) 0 ;
11637 void *argp1 = 0 ;
11638 int res1 = 0 ;
11639 PyObject * obj0 = 0 ;
11640 char * kwnames[] = {
11641 (char *) "ts", NULL
11642 };
11643
11644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11646 if (!SWIG_IsOK(res1)) {
11647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11648 }
11649 arg1 = reinterpret_cast< wxChar * >(argp1);
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 wxLog::SetTimestamp((wxChar const *)arg1);
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 resultobj = SWIG_Py_Void();
11657 return resultobj;
11658 fail:
11659 return NULL;
11660 }
11661
11662
11663 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664 PyObject *resultobj = 0;
11665 bool result;
11666
11667 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11668 {
11669 PyThreadState* __tstate = wxPyBeginAllowThreads();
11670 result = (bool)wxLog::GetVerbose();
11671 wxPyEndAllowThreads(__tstate);
11672 if (PyErr_Occurred()) SWIG_fail;
11673 }
11674 {
11675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11676 }
11677 return resultobj;
11678 fail:
11679 return NULL;
11680 }
11681
11682
11683 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 PyObject *resultobj = 0;
11685 wxTraceMask result;
11686
11687 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11688 {
11689 PyThreadState* __tstate = wxPyBeginAllowThreads();
11690 result = (wxTraceMask)wxLog::GetTraceMask();
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11695 return resultobj;
11696 fail:
11697 return NULL;
11698 }
11699
11700
11701 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11702 PyObject *resultobj = 0;
11703 wxChar *arg1 = (wxChar *) 0 ;
11704 bool result;
11705 void *argp1 = 0 ;
11706 int res1 = 0 ;
11707 PyObject * obj0 = 0 ;
11708 char * kwnames[] = {
11709 (char *) "mask", NULL
11710 };
11711
11712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11714 if (!SWIG_IsOK(res1)) {
11715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11716 }
11717 arg1 = reinterpret_cast< wxChar * >(argp1);
11718 {
11719 PyThreadState* __tstate = wxPyBeginAllowThreads();
11720 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 {
11725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11726 }
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11734 PyObject *resultobj = 0;
11735 wxLogLevel result;
11736
11737 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 result = (wxLogLevel)wxLog::GetLogLevel();
11741 wxPyEndAllowThreads(__tstate);
11742 if (PyErr_Occurred()) SWIG_fail;
11743 }
11744 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11745 return resultobj;
11746 fail:
11747 return NULL;
11748 }
11749
11750
11751 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752 PyObject *resultobj = 0;
11753 wxChar *result = 0 ;
11754
11755 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (wxChar *)wxLog::GetTimestamp();
11759 wxPyEndAllowThreads(__tstate);
11760 if (PyErr_Occurred()) SWIG_fail;
11761 }
11762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11763 return resultobj;
11764 fail:
11765 return NULL;
11766 }
11767
11768
11769 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770 PyObject *resultobj = 0;
11771 wxString result;
11772
11773 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = wxLog_TimeStamp();
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 {
11781 #if wxUSE_UNICODE
11782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11783 #else
11784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11785 #endif
11786 }
11787 return resultobj;
11788 fail:
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 PyObject *resultobj = 0;
11795 wxLog *arg1 = (wxLog *) 0 ;
11796 void *argp1 = 0 ;
11797 int res1 = 0 ;
11798 PyObject *swig_obj[1] ;
11799
11800 if (!args) SWIG_fail;
11801 swig_obj[0] = args;
11802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11803 if (!SWIG_IsOK(res1)) {
11804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11805 }
11806 arg1 = reinterpret_cast< wxLog * >(argp1);
11807 {
11808 PyThreadState* __tstate = wxPyBeginAllowThreads();
11809 wxLog_Destroy(arg1);
11810 wxPyEndAllowThreads(__tstate);
11811 if (PyErr_Occurred()) SWIG_fail;
11812 }
11813 resultobj = SWIG_Py_Void();
11814 return resultobj;
11815 fail:
11816 return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11821 PyObject *obj;
11822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11823 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11824 return SWIG_Py_Void();
11825 }
11826
11827 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11828 return SWIG_Python_InitShadowInstance(args);
11829 }
11830
11831 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11832 PyObject *resultobj = 0;
11833 wxLogStderr *result = 0 ;
11834
11835 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (wxLogStderr *)new wxLogStderr();
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *obj;
11851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11852 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11853 return SWIG_Py_Void();
11854 }
11855
11856 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11857 return SWIG_Python_InitShadowInstance(args);
11858 }
11859
11860 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj = 0;
11862 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11863 wxLogTextCtrl *result = 0 ;
11864 void *argp1 = 0 ;
11865 int res1 = 0 ;
11866 PyObject * obj0 = 0 ;
11867 char * kwnames[] = {
11868 (char *) "pTextCtrl", NULL
11869 };
11870
11871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11873 if (!SWIG_IsOK(res1)) {
11874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11875 }
11876 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11877 {
11878 PyThreadState* __tstate = wxPyBeginAllowThreads();
11879 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11880 wxPyEndAllowThreads(__tstate);
11881 if (PyErr_Occurred()) SWIG_fail;
11882 }
11883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11884 return resultobj;
11885 fail:
11886 return NULL;
11887 }
11888
11889
11890 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11891 PyObject *obj;
11892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11893 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11894 return SWIG_Py_Void();
11895 }
11896
11897 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11898 return SWIG_Python_InitShadowInstance(args);
11899 }
11900
11901 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11902 PyObject *resultobj = 0;
11903 wxLogGui *result = 0 ;
11904
11905 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 result = (wxLogGui *)new wxLogGui();
11909 wxPyEndAllowThreads(__tstate);
11910 if (PyErr_Occurred()) SWIG_fail;
11911 }
11912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11913 return resultobj;
11914 fail:
11915 return NULL;
11916 }
11917
11918
11919 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11920 PyObject *obj;
11921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11922 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11923 return SWIG_Py_Void();
11924 }
11925
11926 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11927 return SWIG_Python_InitShadowInstance(args);
11928 }
11929
11930 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11931 PyObject *resultobj = 0;
11932 wxFrame *arg1 = (wxFrame *) 0 ;
11933 wxString *arg2 = 0 ;
11934 bool arg3 = (bool) true ;
11935 bool arg4 = (bool) true ;
11936 wxLogWindow *result = 0 ;
11937 void *argp1 = 0 ;
11938 int res1 = 0 ;
11939 bool temp2 = false ;
11940 bool val3 ;
11941 int ecode3 = 0 ;
11942 bool val4 ;
11943 int ecode4 = 0 ;
11944 PyObject * obj0 = 0 ;
11945 PyObject * obj1 = 0 ;
11946 PyObject * obj2 = 0 ;
11947 PyObject * obj3 = 0 ;
11948 char * kwnames[] = {
11949 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11950 };
11951
11952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11954 if (!SWIG_IsOK(res1)) {
11955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11956 }
11957 arg1 = reinterpret_cast< wxFrame * >(argp1);
11958 {
11959 arg2 = wxString_in_helper(obj1);
11960 if (arg2 == NULL) SWIG_fail;
11961 temp2 = true;
11962 }
11963 if (obj2) {
11964 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11965 if (!SWIG_IsOK(ecode3)) {
11966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11967 }
11968 arg3 = static_cast< bool >(val3);
11969 }
11970 if (obj3) {
11971 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11972 if (!SWIG_IsOK(ecode4)) {
11973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11974 }
11975 arg4 = static_cast< bool >(val4);
11976 }
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11980 wxPyEndAllowThreads(__tstate);
11981 if (PyErr_Occurred()) SWIG_fail;
11982 }
11983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11984 {
11985 if (temp2)
11986 delete arg2;
11987 }
11988 return resultobj;
11989 fail:
11990 {
11991 if (temp2)
11992 delete arg2;
11993 }
11994 return NULL;
11995 }
11996
11997
11998 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj = 0;
12000 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12001 bool arg2 = (bool) true ;
12002 void *argp1 = 0 ;
12003 int res1 = 0 ;
12004 bool val2 ;
12005 int ecode2 = 0 ;
12006 PyObject * obj0 = 0 ;
12007 PyObject * obj1 = 0 ;
12008 char * kwnames[] = {
12009 (char *) "self",(char *) "bShow", NULL
12010 };
12011
12012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12014 if (!SWIG_IsOK(res1)) {
12015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12016 }
12017 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12018 if (obj1) {
12019 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12020 if (!SWIG_IsOK(ecode2)) {
12021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12022 }
12023 arg2 = static_cast< bool >(val2);
12024 }
12025 {
12026 PyThreadState* __tstate = wxPyBeginAllowThreads();
12027 (arg1)->Show(arg2);
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 resultobj = SWIG_Py_Void();
12032 return resultobj;
12033 fail:
12034 return NULL;
12035 }
12036
12037
12038 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12039 PyObject *resultobj = 0;
12040 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12041 wxFrame *result = 0 ;
12042 void *argp1 = 0 ;
12043 int res1 = 0 ;
12044 PyObject *swig_obj[1] ;
12045
12046 if (!args) SWIG_fail;
12047 swig_obj[0] = args;
12048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12049 if (!SWIG_IsOK(res1)) {
12050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12051 }
12052 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12053 {
12054 PyThreadState* __tstate = wxPyBeginAllowThreads();
12055 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12056 wxPyEndAllowThreads(__tstate);
12057 if (PyErr_Occurred()) SWIG_fail;
12058 }
12059 {
12060 resultobj = wxPyMake_wxObject(result, (bool)0);
12061 }
12062 return resultobj;
12063 fail:
12064 return NULL;
12065 }
12066
12067
12068 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12069 PyObject *resultobj = 0;
12070 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12071 wxLog *result = 0 ;
12072 void *argp1 = 0 ;
12073 int res1 = 0 ;
12074 PyObject *swig_obj[1] ;
12075
12076 if (!args) SWIG_fail;
12077 swig_obj[0] = args;
12078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12079 if (!SWIG_IsOK(res1)) {
12080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12081 }
12082 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12086 wxPyEndAllowThreads(__tstate);
12087 if (PyErr_Occurred()) SWIG_fail;
12088 }
12089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12090 return resultobj;
12091 fail:
12092 return NULL;
12093 }
12094
12095
12096 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12097 PyObject *resultobj = 0;
12098 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12099 bool result;
12100 void *argp1 = 0 ;
12101 int res1 = 0 ;
12102 PyObject *swig_obj[1] ;
12103
12104 if (!args) SWIG_fail;
12105 swig_obj[0] = args;
12106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12107 if (!SWIG_IsOK(res1)) {
12108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12109 }
12110 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
12114 wxPyEndAllowThreads(__tstate);
12115 if (PyErr_Occurred()) SWIG_fail;
12116 }
12117 {
12118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12119 }
12120 return resultobj;
12121 fail:
12122 return NULL;
12123 }
12124
12125
12126 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12127 PyObject *resultobj = 0;
12128 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12129 bool arg2 ;
12130 void *argp1 = 0 ;
12131 int res1 = 0 ;
12132 bool val2 ;
12133 int ecode2 = 0 ;
12134 PyObject * obj0 = 0 ;
12135 PyObject * obj1 = 0 ;
12136 char * kwnames[] = {
12137 (char *) "self",(char *) "bDoPass", NULL
12138 };
12139
12140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12142 if (!SWIG_IsOK(res1)) {
12143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12144 }
12145 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12146 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12147 if (!SWIG_IsOK(ecode2)) {
12148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12149 }
12150 arg2 = static_cast< bool >(val2);
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 (arg1)->PassMessages(arg2);
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 resultobj = SWIG_Py_Void();
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12165 PyObject *obj;
12166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12167 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
12168 return SWIG_Py_Void();
12169 }
12170
12171 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 return SWIG_Python_InitShadowInstance(args);
12173 }
12174
12175 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj = 0;
12177 wxLog *arg1 = (wxLog *) 0 ;
12178 wxLogChain *result = 0 ;
12179 void *argp1 = 0 ;
12180 int res1 = 0 ;
12181 PyObject * obj0 = 0 ;
12182 char * kwnames[] = {
12183 (char *) "logger", NULL
12184 };
12185
12186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12188 if (!SWIG_IsOK(res1)) {
12189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12190 }
12191 arg1 = reinterpret_cast< wxLog * >(argp1);
12192 {
12193 PyThreadState* __tstate = wxPyBeginAllowThreads();
12194 result = (wxLogChain *)new wxLogChain(arg1);
12195 wxPyEndAllowThreads(__tstate);
12196 if (PyErr_Occurred()) SWIG_fail;
12197 }
12198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12199 return resultobj;
12200 fail:
12201 return NULL;
12202 }
12203
12204
12205 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12206 PyObject *resultobj = 0;
12207 wxLogChain *arg1 = (wxLogChain *) 0 ;
12208 wxLog *arg2 = (wxLog *) 0 ;
12209 void *argp1 = 0 ;
12210 int res1 = 0 ;
12211 void *argp2 = 0 ;
12212 int res2 = 0 ;
12213 PyObject * obj0 = 0 ;
12214 PyObject * obj1 = 0 ;
12215 char * kwnames[] = {
12216 (char *) "self",(char *) "logger", NULL
12217 };
12218
12219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12221 if (!SWIG_IsOK(res1)) {
12222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12223 }
12224 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12226 if (!SWIG_IsOK(res2)) {
12227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12228 }
12229 arg2 = reinterpret_cast< wxLog * >(argp2);
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 (arg1)->SetLog(arg2);
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 resultobj = SWIG_Py_Void();
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj = 0;
12245 wxLogChain *arg1 = (wxLogChain *) 0 ;
12246 bool arg2 ;
12247 void *argp1 = 0 ;
12248 int res1 = 0 ;
12249 bool val2 ;
12250 int ecode2 = 0 ;
12251 PyObject * obj0 = 0 ;
12252 PyObject * obj1 = 0 ;
12253 char * kwnames[] = {
12254 (char *) "self",(char *) "bDoPass", NULL
12255 };
12256
12257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12259 if (!SWIG_IsOK(res1)) {
12260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12261 }
12262 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12264 if (!SWIG_IsOK(ecode2)) {
12265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12266 }
12267 arg2 = static_cast< bool >(val2);
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 (arg1)->PassMessages(arg2);
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 resultobj = SWIG_Py_Void();
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12282 PyObject *resultobj = 0;
12283 wxLogChain *arg1 = (wxLogChain *) 0 ;
12284 bool result;
12285 void *argp1 = 0 ;
12286 int res1 = 0 ;
12287 PyObject *swig_obj[1] ;
12288
12289 if (!args) SWIG_fail;
12290 swig_obj[0] = args;
12291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12292 if (!SWIG_IsOK(res1)) {
12293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12294 }
12295 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12296 {
12297 PyThreadState* __tstate = wxPyBeginAllowThreads();
12298 result = (bool)(arg1)->IsPassingMessages();
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 {
12303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12304 }
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12312 PyObject *resultobj = 0;
12313 wxLogChain *arg1 = (wxLogChain *) 0 ;
12314 wxLog *result = 0 ;
12315 void *argp1 = 0 ;
12316 int res1 = 0 ;
12317 PyObject *swig_obj[1] ;
12318
12319 if (!args) SWIG_fail;
12320 swig_obj[0] = args;
12321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12322 if (!SWIG_IsOK(res1)) {
12323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12324 }
12325 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12326 {
12327 PyThreadState* __tstate = wxPyBeginAllowThreads();
12328 result = (wxLog *)(arg1)->GetOldLog();
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12340 PyObject *obj;
12341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12342 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12343 return SWIG_Py_Void();
12344 }
12345
12346 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12347 return SWIG_Python_InitShadowInstance(args);
12348 }
12349
12350 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12351 PyObject *resultobj = 0;
12352 wxLogBuffer *result = 0 ;
12353
12354 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 result = (wxLogBuffer *)new wxLogBuffer();
12358 wxPyEndAllowThreads(__tstate);
12359 if (PyErr_Occurred()) SWIG_fail;
12360 }
12361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12362 return resultobj;
12363 fail:
12364 return NULL;
12365 }
12366
12367
12368 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12369 PyObject *resultobj = 0;
12370 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12371 wxString *result = 0 ;
12372 void *argp1 = 0 ;
12373 int res1 = 0 ;
12374 PyObject *swig_obj[1] ;
12375
12376 if (!args) SWIG_fail;
12377 swig_obj[0] = args;
12378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12379 if (!SWIG_IsOK(res1)) {
12380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12381 }
12382 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 {
12386 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12387 result = (wxString *) &_result_ref;
12388 }
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 {
12393 #if wxUSE_UNICODE
12394 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12395 #else
12396 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12397 #endif
12398 }
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406 PyObject *obj;
12407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12408 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12409 return SWIG_Py_Void();
12410 }
12411
12412 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12413 return SWIG_Python_InitShadowInstance(args);
12414 }
12415
12416 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12417 PyObject *resultobj = 0;
12418 unsigned long result;
12419
12420 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12421 {
12422 PyThreadState* __tstate = wxPyBeginAllowThreads();
12423 result = (unsigned long)wxSysErrorCode();
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj = 0;
12436 unsigned long arg1 = (unsigned long) 0 ;
12437 wxString result;
12438 unsigned long val1 ;
12439 int ecode1 = 0 ;
12440 PyObject * obj0 = 0 ;
12441 char * kwnames[] = {
12442 (char *) "nErrCode", NULL
12443 };
12444
12445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12446 if (obj0) {
12447 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12448 if (!SWIG_IsOK(ecode1)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12450 }
12451 arg1 = static_cast< unsigned long >(val1);
12452 }
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = wxSysErrorMsg(arg1);
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 {
12460 #if wxUSE_UNICODE
12461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12462 #else
12463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12464 #endif
12465 }
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12473 PyObject *resultobj = 0;
12474 wxString *arg1 = 0 ;
12475 bool temp1 = false ;
12476 PyObject * obj0 = 0 ;
12477 char * kwnames[] = {
12478 (char *) "msg", NULL
12479 };
12480
12481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12482 {
12483 arg1 = wxString_in_helper(obj0);
12484 if (arg1 == NULL) SWIG_fail;
12485 temp1 = true;
12486 }
12487 {
12488 PyThreadState* __tstate = wxPyBeginAllowThreads();
12489 wxPyLogFatalError((wxString const &)*arg1);
12490 wxPyEndAllowThreads(__tstate);
12491 if (PyErr_Occurred()) SWIG_fail;
12492 }
12493 resultobj = SWIG_Py_Void();
12494 {
12495 if (temp1)
12496 delete arg1;
12497 }
12498 return resultobj;
12499 fail:
12500 {
12501 if (temp1)
12502 delete arg1;
12503 }
12504 return NULL;
12505 }
12506
12507
12508 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj = 0;
12510 wxString *arg1 = 0 ;
12511 bool temp1 = false ;
12512 PyObject * obj0 = 0 ;
12513 char * kwnames[] = {
12514 (char *) "msg", NULL
12515 };
12516
12517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12518 {
12519 arg1 = wxString_in_helper(obj0);
12520 if (arg1 == NULL) SWIG_fail;
12521 temp1 = true;
12522 }
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 wxPyLogError((wxString const &)*arg1);
12526 wxPyEndAllowThreads(__tstate);
12527 if (PyErr_Occurred()) SWIG_fail;
12528 }
12529 resultobj = SWIG_Py_Void();
12530 {
12531 if (temp1)
12532 delete arg1;
12533 }
12534 return resultobj;
12535 fail:
12536 {
12537 if (temp1)
12538 delete arg1;
12539 }
12540 return NULL;
12541 }
12542
12543
12544 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj = 0;
12546 wxString *arg1 = 0 ;
12547 bool temp1 = false ;
12548 PyObject * obj0 = 0 ;
12549 char * kwnames[] = {
12550 (char *) "msg", NULL
12551 };
12552
12553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12554 {
12555 arg1 = wxString_in_helper(obj0);
12556 if (arg1 == NULL) SWIG_fail;
12557 temp1 = true;
12558 }
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 wxPyLogWarning((wxString const &)*arg1);
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 resultobj = SWIG_Py_Void();
12566 {
12567 if (temp1)
12568 delete arg1;
12569 }
12570 return resultobj;
12571 fail:
12572 {
12573 if (temp1)
12574 delete arg1;
12575 }
12576 return NULL;
12577 }
12578
12579
12580 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj = 0;
12582 wxString *arg1 = 0 ;
12583 bool temp1 = false ;
12584 PyObject * obj0 = 0 ;
12585 char * kwnames[] = {
12586 (char *) "msg", NULL
12587 };
12588
12589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12590 {
12591 arg1 = wxString_in_helper(obj0);
12592 if (arg1 == NULL) SWIG_fail;
12593 temp1 = true;
12594 }
12595 {
12596 PyThreadState* __tstate = wxPyBeginAllowThreads();
12597 wxPyLogMessage((wxString const &)*arg1);
12598 wxPyEndAllowThreads(__tstate);
12599 if (PyErr_Occurred()) SWIG_fail;
12600 }
12601 resultobj = SWIG_Py_Void();
12602 {
12603 if (temp1)
12604 delete arg1;
12605 }
12606 return resultobj;
12607 fail:
12608 {
12609 if (temp1)
12610 delete arg1;
12611 }
12612 return NULL;
12613 }
12614
12615
12616 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12617 PyObject *resultobj = 0;
12618 wxString *arg1 = 0 ;
12619 bool temp1 = false ;
12620 PyObject * obj0 = 0 ;
12621 char * kwnames[] = {
12622 (char *) "msg", NULL
12623 };
12624
12625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12626 {
12627 arg1 = wxString_in_helper(obj0);
12628 if (arg1 == NULL) SWIG_fail;
12629 temp1 = true;
12630 }
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 wxPyLogInfo((wxString const &)*arg1);
12634 wxPyEndAllowThreads(__tstate);
12635 if (PyErr_Occurred()) SWIG_fail;
12636 }
12637 resultobj = SWIG_Py_Void();
12638 {
12639 if (temp1)
12640 delete arg1;
12641 }
12642 return resultobj;
12643 fail:
12644 {
12645 if (temp1)
12646 delete arg1;
12647 }
12648 return NULL;
12649 }
12650
12651
12652 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12653 PyObject *resultobj = 0;
12654 wxString *arg1 = 0 ;
12655 bool temp1 = false ;
12656 PyObject * obj0 = 0 ;
12657 char * kwnames[] = {
12658 (char *) "msg", NULL
12659 };
12660
12661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12662 {
12663 arg1 = wxString_in_helper(obj0);
12664 if (arg1 == NULL) SWIG_fail;
12665 temp1 = true;
12666 }
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 wxPyLogDebug((wxString const &)*arg1);
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 resultobj = SWIG_Py_Void();
12674 {
12675 if (temp1)
12676 delete arg1;
12677 }
12678 return resultobj;
12679 fail:
12680 {
12681 if (temp1)
12682 delete arg1;
12683 }
12684 return NULL;
12685 }
12686
12687
12688 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12689 PyObject *resultobj = 0;
12690 wxString *arg1 = 0 ;
12691 bool temp1 = false ;
12692 PyObject * obj0 = 0 ;
12693 char * kwnames[] = {
12694 (char *) "msg", NULL
12695 };
12696
12697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12698 {
12699 arg1 = wxString_in_helper(obj0);
12700 if (arg1 == NULL) SWIG_fail;
12701 temp1 = true;
12702 }
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 wxPyLogVerbose((wxString const &)*arg1);
12706 wxPyEndAllowThreads(__tstate);
12707 if (PyErr_Occurred()) SWIG_fail;
12708 }
12709 resultobj = SWIG_Py_Void();
12710 {
12711 if (temp1)
12712 delete arg1;
12713 }
12714 return resultobj;
12715 fail:
12716 {
12717 if (temp1)
12718 delete arg1;
12719 }
12720 return NULL;
12721 }
12722
12723
12724 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12725 PyObject *resultobj = 0;
12726 wxString *arg1 = 0 ;
12727 bool temp1 = false ;
12728 PyObject * obj0 = 0 ;
12729 char * kwnames[] = {
12730 (char *) "msg", NULL
12731 };
12732
12733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12734 {
12735 arg1 = wxString_in_helper(obj0);
12736 if (arg1 == NULL) SWIG_fail;
12737 temp1 = true;
12738 }
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 wxPyLogStatus((wxString const &)*arg1);
12742 wxPyEndAllowThreads(__tstate);
12743 if (PyErr_Occurred()) SWIG_fail;
12744 }
12745 resultobj = SWIG_Py_Void();
12746 {
12747 if (temp1)
12748 delete arg1;
12749 }
12750 return resultobj;
12751 fail:
12752 {
12753 if (temp1)
12754 delete arg1;
12755 }
12756 return NULL;
12757 }
12758
12759
12760 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12761 PyObject *resultobj = 0;
12762 wxFrame *arg1 = (wxFrame *) 0 ;
12763 wxString *arg2 = 0 ;
12764 void *argp1 = 0 ;
12765 int res1 = 0 ;
12766 bool temp2 = false ;
12767 PyObject * obj0 = 0 ;
12768 PyObject * obj1 = 0 ;
12769 char * kwnames[] = {
12770 (char *) "pFrame",(char *) "msg", NULL
12771 };
12772
12773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12775 if (!SWIG_IsOK(res1)) {
12776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12777 }
12778 arg1 = reinterpret_cast< wxFrame * >(argp1);
12779 {
12780 arg2 = wxString_in_helper(obj1);
12781 if (arg2 == NULL) SWIG_fail;
12782 temp2 = true;
12783 }
12784 {
12785 PyThreadState* __tstate = wxPyBeginAllowThreads();
12786 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12787 wxPyEndAllowThreads(__tstate);
12788 if (PyErr_Occurred()) SWIG_fail;
12789 }
12790 resultobj = SWIG_Py_Void();
12791 {
12792 if (temp2)
12793 delete arg2;
12794 }
12795 return resultobj;
12796 fail:
12797 {
12798 if (temp2)
12799 delete arg2;
12800 }
12801 return NULL;
12802 }
12803
12804
12805 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12806 PyObject *resultobj = 0;
12807 wxString *arg1 = 0 ;
12808 bool temp1 = false ;
12809 PyObject * obj0 = 0 ;
12810 char * kwnames[] = {
12811 (char *) "msg", NULL
12812 };
12813
12814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12815 {
12816 arg1 = wxString_in_helper(obj0);
12817 if (arg1 == NULL) SWIG_fail;
12818 temp1 = true;
12819 }
12820 {
12821 PyThreadState* __tstate = wxPyBeginAllowThreads();
12822 wxPyLogSysError((wxString const &)*arg1);
12823 wxPyEndAllowThreads(__tstate);
12824 if (PyErr_Occurred()) SWIG_fail;
12825 }
12826 resultobj = SWIG_Py_Void();
12827 {
12828 if (temp1)
12829 delete arg1;
12830 }
12831 return resultobj;
12832 fail:
12833 {
12834 if (temp1)
12835 delete arg1;
12836 }
12837 return NULL;
12838 }
12839
12840
12841 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj = 0;
12843 unsigned long arg1 ;
12844 wxString *arg2 = 0 ;
12845 unsigned long val1 ;
12846 int ecode1 = 0 ;
12847 bool temp2 = false ;
12848 PyObject * obj0 = 0 ;
12849 PyObject * obj1 = 0 ;
12850 char * kwnames[] = {
12851 (char *) "level",(char *) "msg", NULL
12852 };
12853
12854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12855 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12856 if (!SWIG_IsOK(ecode1)) {
12857 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12858 }
12859 arg1 = static_cast< unsigned long >(val1);
12860 {
12861 arg2 = wxString_in_helper(obj1);
12862 if (arg2 == NULL) SWIG_fail;
12863 temp2 = true;
12864 }
12865 {
12866 PyThreadState* __tstate = wxPyBeginAllowThreads();
12867 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12868 wxPyEndAllowThreads(__tstate);
12869 if (PyErr_Occurred()) SWIG_fail;
12870 }
12871 resultobj = SWIG_Py_Void();
12872 {
12873 if (temp2)
12874 delete arg2;
12875 }
12876 return resultobj;
12877 fail:
12878 {
12879 if (temp2)
12880 delete arg2;
12881 }
12882 return NULL;
12883 }
12884
12885
12886 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12887 PyObject *resultobj = 0;
12888 unsigned long arg1 ;
12889 wxString *arg2 = 0 ;
12890 unsigned long val1 ;
12891 int ecode1 = 0 ;
12892 bool temp2 = false ;
12893
12894 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12895 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12896 if (!SWIG_IsOK(ecode1)) {
12897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12898 }
12899 arg1 = static_cast< unsigned long >(val1);
12900 {
12901 arg2 = wxString_in_helper(swig_obj[1]);
12902 if (arg2 == NULL) SWIG_fail;
12903 temp2 = true;
12904 }
12905 {
12906 PyThreadState* __tstate = wxPyBeginAllowThreads();
12907 wxPyLogTrace(arg1,(wxString const &)*arg2);
12908 wxPyEndAllowThreads(__tstate);
12909 if (PyErr_Occurred()) SWIG_fail;
12910 }
12911 resultobj = SWIG_Py_Void();
12912 {
12913 if (temp2)
12914 delete arg2;
12915 }
12916 return resultobj;
12917 fail:
12918 {
12919 if (temp2)
12920 delete arg2;
12921 }
12922 return NULL;
12923 }
12924
12925
12926 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12927 PyObject *resultobj = 0;
12928 wxString *arg1 = 0 ;
12929 wxString *arg2 = 0 ;
12930 bool temp1 = false ;
12931 bool temp2 = false ;
12932
12933 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12934 {
12935 arg1 = wxString_in_helper(swig_obj[0]);
12936 if (arg1 == NULL) SWIG_fail;
12937 temp1 = true;
12938 }
12939 {
12940 arg2 = wxString_in_helper(swig_obj[1]);
12941 if (arg2 == NULL) SWIG_fail;
12942 temp2 = true;
12943 }
12944 {
12945 PyThreadState* __tstate = wxPyBeginAllowThreads();
12946 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12947 wxPyEndAllowThreads(__tstate);
12948 if (PyErr_Occurred()) SWIG_fail;
12949 }
12950 resultobj = SWIG_Py_Void();
12951 {
12952 if (temp1)
12953 delete arg1;
12954 }
12955 {
12956 if (temp2)
12957 delete arg2;
12958 }
12959 return resultobj;
12960 fail:
12961 {
12962 if (temp1)
12963 delete arg1;
12964 }
12965 {
12966 if (temp2)
12967 delete arg2;
12968 }
12969 return NULL;
12970 }
12971
12972
12973 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12974 int argc;
12975 PyObject *argv[3];
12976
12977 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12978 --argc;
12979 if (argc == 2) {
12980 int _v = 0;
12981 {
12982 {
12983 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12984 }
12985 }
12986 if (!_v) goto check_1;
12987 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12988 }
12989 check_1:
12990
12991 if (argc == 2) {
12992 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12993 }
12994
12995 fail:
12996 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13002 PyObject *resultobj = 0;
13003 wxString *arg1 = 0 ;
13004 wxString *arg2 = 0 ;
13005 bool temp1 = false ;
13006 bool temp2 = false ;
13007 PyObject * obj0 = 0 ;
13008 PyObject * obj1 = 0 ;
13009 char * kwnames[] = {
13010 (char *) "title",(char *) "text", NULL
13011 };
13012
13013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13014 {
13015 arg1 = wxString_in_helper(obj0);
13016 if (arg1 == NULL) SWIG_fail;
13017 temp1 = true;
13018 }
13019 {
13020 arg2 = wxString_in_helper(obj1);
13021 if (arg2 == NULL) SWIG_fail;
13022 temp2 = true;
13023 }
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 resultobj = SWIG_Py_Void();
13031 {
13032 if (temp1)
13033 delete arg1;
13034 }
13035 {
13036 if (temp2)
13037 delete arg2;
13038 }
13039 return resultobj;
13040 fail:
13041 {
13042 if (temp1)
13043 delete arg1;
13044 }
13045 {
13046 if (temp2)
13047 delete arg2;
13048 }
13049 return NULL;
13050 }
13051
13052
13053 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13054 PyObject *resultobj = 0;
13055 wxLogNull *result = 0 ;
13056
13057 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13058 {
13059 PyThreadState* __tstate = wxPyBeginAllowThreads();
13060 result = (wxLogNull *)new wxLogNull();
13061 wxPyEndAllowThreads(__tstate);
13062 if (PyErr_Occurred()) SWIG_fail;
13063 }
13064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13072 PyObject *resultobj = 0;
13073 wxLogNull *arg1 = (wxLogNull *) 0 ;
13074 void *argp1 = 0 ;
13075 int res1 = 0 ;
13076 PyObject *swig_obj[1] ;
13077
13078 if (!args) SWIG_fail;
13079 swig_obj[0] = args;
13080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13081 if (!SWIG_IsOK(res1)) {
13082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13083 }
13084 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13085 {
13086 PyThreadState* __tstate = wxPyBeginAllowThreads();
13087 delete arg1;
13088
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 resultobj = SWIG_Py_Void();
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13100 PyObject *obj;
13101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13102 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13103 return SWIG_Py_Void();
13104 }
13105
13106 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13107 return SWIG_Python_InitShadowInstance(args);
13108 }
13109
13110 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13111 PyObject *resultobj = 0;
13112 wxPyLog *result = 0 ;
13113
13114 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 result = (wxPyLog *)new wxPyLog();
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj = 0;
13130 wxPyLog *arg1 = (wxPyLog *) 0 ;
13131 PyObject *arg2 = (PyObject *) 0 ;
13132 PyObject *arg3 = (PyObject *) 0 ;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 PyObject * obj0 = 0 ;
13136 PyObject * obj1 = 0 ;
13137 PyObject * obj2 = 0 ;
13138 char * kwnames[] = {
13139 (char *) "self",(char *) "self",(char *) "_class", NULL
13140 };
13141
13142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
13144 if (!SWIG_IsOK(res1)) {
13145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
13146 }
13147 arg1 = reinterpret_cast< wxPyLog * >(argp1);
13148 arg2 = obj1;
13149 arg3 = obj2;
13150 {
13151 PyThreadState* __tstate = wxPyBeginAllowThreads();
13152 (arg1)->_setCallbackInfo(arg2,arg3);
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 resultobj = SWIG_Py_Void();
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13164 PyObject *obj;
13165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13166 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
13167 return SWIG_Py_Void();
13168 }
13169
13170 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13171 return SWIG_Python_InitShadowInstance(args);
13172 }
13173
13174 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13175 PyObject *resultobj = 0;
13176 int arg1 ;
13177 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13178 int arg3 = (int) wxKILL_NOCHILDREN ;
13179 wxKillError result;
13180 int val1 ;
13181 int ecode1 = 0 ;
13182 int val2 ;
13183 int ecode2 = 0 ;
13184 int val3 ;
13185 int ecode3 = 0 ;
13186 PyObject * obj0 = 0 ;
13187 PyObject * obj1 = 0 ;
13188 PyObject * obj2 = 0 ;
13189 char * kwnames[] = {
13190 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13191 };
13192
13193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13194 ecode1 = SWIG_AsVal_int(obj0, &val1);
13195 if (!SWIG_IsOK(ecode1)) {
13196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13197 }
13198 arg1 = static_cast< int >(val1);
13199 if (obj1) {
13200 ecode2 = SWIG_AsVal_int(obj1, &val2);
13201 if (!SWIG_IsOK(ecode2)) {
13202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13203 }
13204 arg2 = static_cast< wxSignal >(val2);
13205 }
13206 if (obj2) {
13207 ecode3 = SWIG_AsVal_int(obj2, &val3);
13208 if (!SWIG_IsOK(ecode3)) {
13209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13210 }
13211 arg3 = static_cast< int >(val3);
13212 }
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 resultobj = SWIG_From_int(static_cast< int >(result));
13220 return resultobj;
13221 fail:
13222 return NULL;
13223 }
13224
13225
13226 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13227 PyObject *resultobj = 0;
13228 int arg1 ;
13229 bool result;
13230 int val1 ;
13231 int ecode1 = 0 ;
13232 PyObject * obj0 = 0 ;
13233 char * kwnames[] = {
13234 (char *) "pid", NULL
13235 };
13236
13237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13238 ecode1 = SWIG_AsVal_int(obj0, &val1);
13239 if (!SWIG_IsOK(ecode1)) {
13240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13241 }
13242 arg1 = static_cast< int >(val1);
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 result = (bool)wxPyProcess::Exists(arg1);
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 {
13250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13251 }
13252 return resultobj;
13253 fail:
13254 return NULL;
13255 }
13256
13257
13258 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13259 PyObject *resultobj = 0;
13260 wxString *arg1 = 0 ;
13261 int arg2 = (int) wxEXEC_ASYNC ;
13262 wxPyProcess *result = 0 ;
13263 bool temp1 = false ;
13264 int val2 ;
13265 int ecode2 = 0 ;
13266 PyObject * obj0 = 0 ;
13267 PyObject * obj1 = 0 ;
13268 char * kwnames[] = {
13269 (char *) "cmd",(char *) "flags", NULL
13270 };
13271
13272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13273 {
13274 arg1 = wxString_in_helper(obj0);
13275 if (arg1 == NULL) SWIG_fail;
13276 temp1 = true;
13277 }
13278 if (obj1) {
13279 ecode2 = SWIG_AsVal_int(obj1, &val2);
13280 if (!SWIG_IsOK(ecode2)) {
13281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13282 }
13283 arg2 = static_cast< int >(val2);
13284 }
13285 {
13286 PyThreadState* __tstate = wxPyBeginAllowThreads();
13287 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13288 wxPyEndAllowThreads(__tstate);
13289 if (PyErr_Occurred()) SWIG_fail;
13290 }
13291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13292 {
13293 if (temp1)
13294 delete arg1;
13295 }
13296 return resultobj;
13297 fail:
13298 {
13299 if (temp1)
13300 delete arg1;
13301 }
13302 return NULL;
13303 }
13304
13305
13306 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13307 PyObject *resultobj = 0;
13308 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13309 int arg2 = (int) -1 ;
13310 wxPyProcess *result = 0 ;
13311 void *argp1 = 0 ;
13312 int res1 = 0 ;
13313 int val2 ;
13314 int ecode2 = 0 ;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 char * kwnames[] = {
13318 (char *) "parent",(char *) "id", NULL
13319 };
13320
13321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13322 if (obj0) {
13323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13326 }
13327 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13328 }
13329 if (obj1) {
13330 ecode2 = SWIG_AsVal_int(obj1, &val2);
13331 if (!SWIG_IsOK(ecode2)) {
13332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13333 }
13334 arg2 = static_cast< int >(val2);
13335 }
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13343 return resultobj;
13344 fail:
13345 return NULL;
13346 }
13347
13348
13349 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13350 PyObject *resultobj = 0;
13351 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13352 PyObject *arg2 = (PyObject *) 0 ;
13353 PyObject *arg3 = (PyObject *) 0 ;
13354 void *argp1 = 0 ;
13355 int res1 = 0 ;
13356 PyObject * obj0 = 0 ;
13357 PyObject * obj1 = 0 ;
13358 PyObject * obj2 = 0 ;
13359 char * kwnames[] = {
13360 (char *) "self",(char *) "self",(char *) "_class", NULL
13361 };
13362
13363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13365 if (!SWIG_IsOK(res1)) {
13366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13367 }
13368 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13369 arg2 = obj1;
13370 arg3 = obj2;
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 (arg1)->_setCallbackInfo(arg2,arg3);
13374 wxPyEndAllowThreads(__tstate);
13375 if (PyErr_Occurred()) SWIG_fail;
13376 }
13377 resultobj = SWIG_Py_Void();
13378 return resultobj;
13379 fail:
13380 return NULL;
13381 }
13382
13383
13384 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13385 PyObject *resultobj = 0;
13386 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13387 int arg2 ;
13388 int arg3 ;
13389 void *argp1 = 0 ;
13390 int res1 = 0 ;
13391 int val2 ;
13392 int ecode2 = 0 ;
13393 int val3 ;
13394 int ecode3 = 0 ;
13395 PyObject * obj0 = 0 ;
13396 PyObject * obj1 = 0 ;
13397 PyObject * obj2 = 0 ;
13398 char * kwnames[] = {
13399 (char *) "self",(char *) "pid",(char *) "status", NULL
13400 };
13401
13402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13404 if (!SWIG_IsOK(res1)) {
13405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13406 }
13407 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13408 ecode2 = SWIG_AsVal_int(obj1, &val2);
13409 if (!SWIG_IsOK(ecode2)) {
13410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13411 }
13412 arg2 = static_cast< int >(val2);
13413 ecode3 = SWIG_AsVal_int(obj2, &val3);
13414 if (!SWIG_IsOK(ecode3)) {
13415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13416 }
13417 arg3 = static_cast< int >(val3);
13418 {
13419 PyThreadState* __tstate = wxPyBeginAllowThreads();
13420 (arg1)->OnTerminate(arg2,arg3);
13421 wxPyEndAllowThreads(__tstate);
13422 if (PyErr_Occurred()) SWIG_fail;
13423 }
13424 resultobj = SWIG_Py_Void();
13425 return resultobj;
13426 fail:
13427 return NULL;
13428 }
13429
13430
13431 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432 PyObject *resultobj = 0;
13433 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13434 void *argp1 = 0 ;
13435 int res1 = 0 ;
13436 PyObject *swig_obj[1] ;
13437
13438 if (!args) SWIG_fail;
13439 swig_obj[0] = args;
13440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13441 if (!SWIG_IsOK(res1)) {
13442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13443 }
13444 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13445 {
13446 PyThreadState* __tstate = wxPyBeginAllowThreads();
13447 (arg1)->Redirect();
13448 wxPyEndAllowThreads(__tstate);
13449 if (PyErr_Occurred()) SWIG_fail;
13450 }
13451 resultobj = SWIG_Py_Void();
13452 return resultobj;
13453 fail:
13454 return NULL;
13455 }
13456
13457
13458 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13459 PyObject *resultobj = 0;
13460 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13461 bool result;
13462 void *argp1 = 0 ;
13463 int res1 = 0 ;
13464 PyObject *swig_obj[1] ;
13465
13466 if (!args) SWIG_fail;
13467 swig_obj[0] = args;
13468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13469 if (!SWIG_IsOK(res1)) {
13470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13471 }
13472 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 result = (bool)(arg1)->IsRedirected();
13476 wxPyEndAllowThreads(__tstate);
13477 if (PyErr_Occurred()) SWIG_fail;
13478 }
13479 {
13480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13481 }
13482 return resultobj;
13483 fail:
13484 return NULL;
13485 }
13486
13487
13488 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13489 PyObject *resultobj = 0;
13490 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13491 void *argp1 = 0 ;
13492 int res1 = 0 ;
13493 PyObject *swig_obj[1] ;
13494
13495 if (!args) SWIG_fail;
13496 swig_obj[0] = args;
13497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13500 }
13501 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 (arg1)->Detach();
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 resultobj = SWIG_Py_Void();
13509 return resultobj;
13510 fail:
13511 return NULL;
13512 }
13513
13514
13515 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13516 PyObject *resultobj = 0;
13517 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13518 wxInputStream *result = 0 ;
13519 void *argp1 = 0 ;
13520 int res1 = 0 ;
13521 PyObject *swig_obj[1] ;
13522
13523 if (!args) SWIG_fail;
13524 swig_obj[0] = args;
13525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13526 if (!SWIG_IsOK(res1)) {
13527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13528 }
13529 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (wxInputStream *)(arg1)->GetInputStream();
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 {
13537 wxPyInputStream * _ptr = NULL;
13538
13539 if (result) {
13540 _ptr = new wxPyInputStream(result);
13541 }
13542 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13543 }
13544 return resultobj;
13545 fail:
13546 return NULL;
13547 }
13548
13549
13550 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13551 PyObject *resultobj = 0;
13552 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13553 wxInputStream *result = 0 ;
13554 void *argp1 = 0 ;
13555 int res1 = 0 ;
13556 PyObject *swig_obj[1] ;
13557
13558 if (!args) SWIG_fail;
13559 swig_obj[0] = args;
13560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13561 if (!SWIG_IsOK(res1)) {
13562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13563 }
13564 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13565 {
13566 PyThreadState* __tstate = wxPyBeginAllowThreads();
13567 result = (wxInputStream *)(arg1)->GetErrorStream();
13568 wxPyEndAllowThreads(__tstate);
13569 if (PyErr_Occurred()) SWIG_fail;
13570 }
13571 {
13572 wxPyInputStream * _ptr = NULL;
13573
13574 if (result) {
13575 _ptr = new wxPyInputStream(result);
13576 }
13577 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13578 }
13579 return resultobj;
13580 fail:
13581 return NULL;
13582 }
13583
13584
13585 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13586 PyObject *resultobj = 0;
13587 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13588 wxOutputStream *result = 0 ;
13589 void *argp1 = 0 ;
13590 int res1 = 0 ;
13591 PyObject *swig_obj[1] ;
13592
13593 if (!args) SWIG_fail;
13594 swig_obj[0] = args;
13595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13596 if (!SWIG_IsOK(res1)) {
13597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13598 }
13599 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13600 {
13601 PyThreadState* __tstate = wxPyBeginAllowThreads();
13602 result = (wxOutputStream *)(arg1)->GetOutputStream();
13603 wxPyEndAllowThreads(__tstate);
13604 if (PyErr_Occurred()) SWIG_fail;
13605 }
13606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13607 return resultobj;
13608 fail:
13609 return NULL;
13610 }
13611
13612
13613 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13614 PyObject *resultobj = 0;
13615 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13616 void *argp1 = 0 ;
13617 int res1 = 0 ;
13618 PyObject *swig_obj[1] ;
13619
13620 if (!args) SWIG_fail;
13621 swig_obj[0] = args;
13622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13623 if (!SWIG_IsOK(res1)) {
13624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13625 }
13626 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13627 {
13628 PyThreadState* __tstate = wxPyBeginAllowThreads();
13629 (arg1)->CloseOutput();
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 resultobj = SWIG_Py_Void();
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13641 PyObject *resultobj = 0;
13642 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13643 bool result;
13644 void *argp1 = 0 ;
13645 int res1 = 0 ;
13646 PyObject *swig_obj[1] ;
13647
13648 if (!args) SWIG_fail;
13649 swig_obj[0] = args;
13650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13651 if (!SWIG_IsOK(res1)) {
13652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13653 }
13654 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13655 {
13656 PyThreadState* __tstate = wxPyBeginAllowThreads();
13657 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13658 wxPyEndAllowThreads(__tstate);
13659 if (PyErr_Occurred()) SWIG_fail;
13660 }
13661 {
13662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13663 }
13664 return resultobj;
13665 fail:
13666 return NULL;
13667 }
13668
13669
13670 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13671 PyObject *resultobj = 0;
13672 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13673 bool result;
13674 void *argp1 = 0 ;
13675 int res1 = 0 ;
13676 PyObject *swig_obj[1] ;
13677
13678 if (!args) SWIG_fail;
13679 swig_obj[0] = args;
13680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13681 if (!SWIG_IsOK(res1)) {
13682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13683 }
13684 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13688 wxPyEndAllowThreads(__tstate);
13689 if (PyErr_Occurred()) SWIG_fail;
13690 }
13691 {
13692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13693 }
13694 return resultobj;
13695 fail:
13696 return NULL;
13697 }
13698
13699
13700 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13701 PyObject *resultobj = 0;
13702 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13703 bool result;
13704 void *argp1 = 0 ;
13705 int res1 = 0 ;
13706 PyObject *swig_obj[1] ;
13707
13708 if (!args) SWIG_fail;
13709 swig_obj[0] = args;
13710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13711 if (!SWIG_IsOK(res1)) {
13712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13713 }
13714 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13715 {
13716 PyThreadState* __tstate = wxPyBeginAllowThreads();
13717 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 {
13722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13723 }
13724 return resultobj;
13725 fail:
13726 return NULL;
13727 }
13728
13729
13730 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13731 PyObject *obj;
13732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13733 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13734 return SWIG_Py_Void();
13735 }
13736
13737 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13738 return SWIG_Python_InitShadowInstance(args);
13739 }
13740
13741 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj = 0;
13743 int arg1 = (int) 0 ;
13744 int arg2 = (int) 0 ;
13745 int arg3 = (int) 0 ;
13746 wxProcessEvent *result = 0 ;
13747 int val1 ;
13748 int ecode1 = 0 ;
13749 int val2 ;
13750 int ecode2 = 0 ;
13751 int val3 ;
13752 int ecode3 = 0 ;
13753 PyObject * obj0 = 0 ;
13754 PyObject * obj1 = 0 ;
13755 PyObject * obj2 = 0 ;
13756 char * kwnames[] = {
13757 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13758 };
13759
13760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13761 if (obj0) {
13762 ecode1 = SWIG_AsVal_int(obj0, &val1);
13763 if (!SWIG_IsOK(ecode1)) {
13764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13765 }
13766 arg1 = static_cast< int >(val1);
13767 }
13768 if (obj1) {
13769 ecode2 = SWIG_AsVal_int(obj1, &val2);
13770 if (!SWIG_IsOK(ecode2)) {
13771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13772 }
13773 arg2 = static_cast< int >(val2);
13774 }
13775 if (obj2) {
13776 ecode3 = SWIG_AsVal_int(obj2, &val3);
13777 if (!SWIG_IsOK(ecode3)) {
13778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13779 }
13780 arg3 = static_cast< int >(val3);
13781 }
13782 {
13783 PyThreadState* __tstate = wxPyBeginAllowThreads();
13784 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13785 wxPyEndAllowThreads(__tstate);
13786 if (PyErr_Occurred()) SWIG_fail;
13787 }
13788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13789 return resultobj;
13790 fail:
13791 return NULL;
13792 }
13793
13794
13795 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13796 PyObject *resultobj = 0;
13797 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13798 int result;
13799 void *argp1 = 0 ;
13800 int res1 = 0 ;
13801 PyObject *swig_obj[1] ;
13802
13803 if (!args) SWIG_fail;
13804 swig_obj[0] = args;
13805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13806 if (!SWIG_IsOK(res1)) {
13807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13808 }
13809 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13810 {
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 result = (int)(arg1)->GetPid();
13813 wxPyEndAllowThreads(__tstate);
13814 if (PyErr_Occurred()) SWIG_fail;
13815 }
13816 resultobj = SWIG_From_int(static_cast< int >(result));
13817 return resultobj;
13818 fail:
13819 return NULL;
13820 }
13821
13822
13823 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13824 PyObject *resultobj = 0;
13825 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13826 int result;
13827 void *argp1 = 0 ;
13828 int res1 = 0 ;
13829 PyObject *swig_obj[1] ;
13830
13831 if (!args) SWIG_fail;
13832 swig_obj[0] = args;
13833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13834 if (!SWIG_IsOK(res1)) {
13835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13836 }
13837 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13838 {
13839 PyThreadState* __tstate = wxPyBeginAllowThreads();
13840 result = (int)(arg1)->GetExitCode();
13841 wxPyEndAllowThreads(__tstate);
13842 if (PyErr_Occurred()) SWIG_fail;
13843 }
13844 resultobj = SWIG_From_int(static_cast< int >(result));
13845 return resultobj;
13846 fail:
13847 return NULL;
13848 }
13849
13850
13851 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13852 PyObject *resultobj = 0;
13853 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13854 int arg2 ;
13855 void *argp1 = 0 ;
13856 int res1 = 0 ;
13857 int val2 ;
13858 int ecode2 = 0 ;
13859 PyObject *swig_obj[2] ;
13860
13861 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13863 if (!SWIG_IsOK(res1)) {
13864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13865 }
13866 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13867 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13868 if (!SWIG_IsOK(ecode2)) {
13869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13870 }
13871 arg2 = static_cast< int >(val2);
13872 if (arg1) (arg1)->m_pid = arg2;
13873
13874 resultobj = SWIG_Py_Void();
13875 return resultobj;
13876 fail:
13877 return NULL;
13878 }
13879
13880
13881 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13882 PyObject *resultobj = 0;
13883 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13884 int result;
13885 void *argp1 = 0 ;
13886 int res1 = 0 ;
13887 PyObject *swig_obj[1] ;
13888
13889 if (!args) SWIG_fail;
13890 swig_obj[0] = args;
13891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13892 if (!SWIG_IsOK(res1)) {
13893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13894 }
13895 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13896 result = (int) ((arg1)->m_pid);
13897 resultobj = SWIG_From_int(static_cast< int >(result));
13898 return resultobj;
13899 fail:
13900 return NULL;
13901 }
13902
13903
13904 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13905 PyObject *resultobj = 0;
13906 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13907 int arg2 ;
13908 void *argp1 = 0 ;
13909 int res1 = 0 ;
13910 int val2 ;
13911 int ecode2 = 0 ;
13912 PyObject *swig_obj[2] ;
13913
13914 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13916 if (!SWIG_IsOK(res1)) {
13917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13918 }
13919 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13920 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13921 if (!SWIG_IsOK(ecode2)) {
13922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13923 }
13924 arg2 = static_cast< int >(val2);
13925 if (arg1) (arg1)->m_exitcode = arg2;
13926
13927 resultobj = SWIG_Py_Void();
13928 return resultobj;
13929 fail:
13930 return NULL;
13931 }
13932
13933
13934 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13935 PyObject *resultobj = 0;
13936 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13937 int result;
13938 void *argp1 = 0 ;
13939 int res1 = 0 ;
13940 PyObject *swig_obj[1] ;
13941
13942 if (!args) SWIG_fail;
13943 swig_obj[0] = args;
13944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13945 if (!SWIG_IsOK(res1)) {
13946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13947 }
13948 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13949 result = (int) ((arg1)->m_exitcode);
13950 resultobj = SWIG_From_int(static_cast< int >(result));
13951 return resultobj;
13952 fail:
13953 return NULL;
13954 }
13955
13956
13957 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13958 PyObject *obj;
13959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13960 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13961 return SWIG_Py_Void();
13962 }
13963
13964 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13965 return SWIG_Python_InitShadowInstance(args);
13966 }
13967
13968 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13969 PyObject *resultobj = 0;
13970 wxString *arg1 = 0 ;
13971 int arg2 = (int) wxEXEC_ASYNC ;
13972 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13973 long result;
13974 bool temp1 = false ;
13975 int val2 ;
13976 int ecode2 = 0 ;
13977 void *argp3 = 0 ;
13978 int res3 = 0 ;
13979 PyObject * obj0 = 0 ;
13980 PyObject * obj1 = 0 ;
13981 PyObject * obj2 = 0 ;
13982 char * kwnames[] = {
13983 (char *) "command",(char *) "flags",(char *) "process", NULL
13984 };
13985
13986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13987 {
13988 arg1 = wxString_in_helper(obj0);
13989 if (arg1 == NULL) SWIG_fail;
13990 temp1 = true;
13991 }
13992 if (obj1) {
13993 ecode2 = SWIG_AsVal_int(obj1, &val2);
13994 if (!SWIG_IsOK(ecode2)) {
13995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13996 }
13997 arg2 = static_cast< int >(val2);
13998 }
13999 if (obj2) {
14000 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14001 if (!SWIG_IsOK(res3)) {
14002 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14003 }
14004 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14005 }
14006 {
14007 if (!wxPyCheckForApp()) SWIG_fail;
14008 PyThreadState* __tstate = wxPyBeginAllowThreads();
14009 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14010 wxPyEndAllowThreads(__tstate);
14011 if (PyErr_Occurred()) SWIG_fail;
14012 }
14013 resultobj = SWIG_From_long(static_cast< long >(result));
14014 {
14015 if (temp1)
14016 delete arg1;
14017 }
14018 return resultobj;
14019 fail:
14020 {
14021 if (temp1)
14022 delete arg1;
14023 }
14024 return NULL;
14025 }
14026
14027
14028 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14029 PyObject *resultobj = 0;
14030 long arg1 ;
14031 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14032 wxKillError *arg3 = (wxKillError *) 0 ;
14033 int arg4 = (int) wxKILL_NOCHILDREN ;
14034 int result;
14035 long val1 ;
14036 int ecode1 = 0 ;
14037 int val2 ;
14038 int ecode2 = 0 ;
14039 wxKillError temp3 ;
14040 int val4 ;
14041 int ecode4 = 0 ;
14042 PyObject * obj0 = 0 ;
14043 PyObject * obj1 = 0 ;
14044 PyObject * obj2 = 0 ;
14045 char * kwnames[] = {
14046 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14047 };
14048
14049 {
14050 arg3 = &temp3;
14051 }
14052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14053 ecode1 = SWIG_AsVal_long(obj0, &val1);
14054 if (!SWIG_IsOK(ecode1)) {
14055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14056 }
14057 arg1 = static_cast< long >(val1);
14058 if (obj1) {
14059 ecode2 = SWIG_AsVal_int(obj1, &val2);
14060 if (!SWIG_IsOK(ecode2)) {
14061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14062 }
14063 arg2 = static_cast< wxSignal >(val2);
14064 }
14065 if (obj2) {
14066 ecode4 = SWIG_AsVal_int(obj2, &val4);
14067 if (!SWIG_IsOK(ecode4)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14069 }
14070 arg4 = static_cast< int >(val4);
14071 }
14072 {
14073 PyThreadState* __tstate = wxPyBeginAllowThreads();
14074 result = (int)wxKill(arg1,arg2,arg3,arg4);
14075 wxPyEndAllowThreads(__tstate);
14076 if (PyErr_Occurred()) SWIG_fail;
14077 }
14078 resultobj = SWIG_From_int(static_cast< int >(result));
14079 {
14080 PyObject* o;
14081 o = PyInt_FromLong((long) (*arg3));
14082
14083
14084
14085 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14086
14087 }
14088 return resultobj;
14089 fail:
14090 return NULL;
14091 }
14092
14093
14094 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj = 0;
14096 int arg1 = (int) wxJOYSTICK1 ;
14097 wxJoystick *result = 0 ;
14098 int val1 ;
14099 int ecode1 = 0 ;
14100 PyObject * obj0 = 0 ;
14101 char * kwnames[] = {
14102 (char *) "joystick", NULL
14103 };
14104
14105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14106 if (obj0) {
14107 ecode1 = SWIG_AsVal_int(obj0, &val1);
14108 if (!SWIG_IsOK(ecode1)) {
14109 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
14110 }
14111 arg1 = static_cast< int >(val1);
14112 }
14113 {
14114 if (!wxPyCheckForApp()) SWIG_fail;
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 result = (wxJoystick *)new wxJoystick(arg1);
14117 wxPyEndAllowThreads(__tstate);
14118 if (PyErr_Occurred()) SWIG_fail;
14119 }
14120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
14121 return resultobj;
14122 fail:
14123 return NULL;
14124 }
14125
14126
14127 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14128 PyObject *resultobj = 0;
14129 wxJoystick *arg1 = (wxJoystick *) 0 ;
14130 void *argp1 = 0 ;
14131 int res1 = 0 ;
14132 PyObject *swig_obj[1] ;
14133
14134 if (!args) SWIG_fail;
14135 swig_obj[0] = args;
14136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
14137 if (!SWIG_IsOK(res1)) {
14138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
14139 }
14140 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14141 {
14142 PyThreadState* __tstate = wxPyBeginAllowThreads();
14143 delete arg1;
14144
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 resultobj = SWIG_Py_Void();
14149 return resultobj;
14150 fail:
14151 return NULL;
14152 }
14153
14154
14155 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14156 PyObject *resultobj = 0;
14157 wxJoystick *arg1 = (wxJoystick *) 0 ;
14158 wxPoint result;
14159 void *argp1 = 0 ;
14160 int res1 = 0 ;
14161 PyObject *swig_obj[1] ;
14162
14163 if (!args) SWIG_fail;
14164 swig_obj[0] = args;
14165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14166 if (!SWIG_IsOK(res1)) {
14167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14168 }
14169 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 result = (arg1)->GetPosition();
14173 wxPyEndAllowThreads(__tstate);
14174 if (PyErr_Occurred()) SWIG_fail;
14175 }
14176 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14177 return resultobj;
14178 fail:
14179 return NULL;
14180 }
14181
14182
14183 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14184 PyObject *resultobj = 0;
14185 wxJoystick *arg1 = (wxJoystick *) 0 ;
14186 int result;
14187 void *argp1 = 0 ;
14188 int res1 = 0 ;
14189 PyObject *swig_obj[1] ;
14190
14191 if (!args) SWIG_fail;
14192 swig_obj[0] = args;
14193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14194 if (!SWIG_IsOK(res1)) {
14195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14196 }
14197 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14198 {
14199 PyThreadState* __tstate = wxPyBeginAllowThreads();
14200 result = (int)(arg1)->GetZPosition();
14201 wxPyEndAllowThreads(__tstate);
14202 if (PyErr_Occurred()) SWIG_fail;
14203 }
14204 resultobj = SWIG_From_int(static_cast< int >(result));
14205 return resultobj;
14206 fail:
14207 return NULL;
14208 }
14209
14210
14211 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14212 PyObject *resultobj = 0;
14213 wxJoystick *arg1 = (wxJoystick *) 0 ;
14214 int result;
14215 void *argp1 = 0 ;
14216 int res1 = 0 ;
14217 PyObject *swig_obj[1] ;
14218
14219 if (!args) SWIG_fail;
14220 swig_obj[0] = args;
14221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14222 if (!SWIG_IsOK(res1)) {
14223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14224 }
14225 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 result = (int)(arg1)->GetButtonState();
14229 wxPyEndAllowThreads(__tstate);
14230 if (PyErr_Occurred()) SWIG_fail;
14231 }
14232 resultobj = SWIG_From_int(static_cast< int >(result));
14233 return resultobj;
14234 fail:
14235 return NULL;
14236 }
14237
14238
14239 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14240 PyObject *resultobj = 0;
14241 wxJoystick *arg1 = (wxJoystick *) 0 ;
14242 int result;
14243 void *argp1 = 0 ;
14244 int res1 = 0 ;
14245 PyObject *swig_obj[1] ;
14246
14247 if (!args) SWIG_fail;
14248 swig_obj[0] = args;
14249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14250 if (!SWIG_IsOK(res1)) {
14251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14252 }
14253 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (int)(arg1)->GetPOVPosition();
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 resultobj = SWIG_From_int(static_cast< int >(result));
14261 return resultobj;
14262 fail:
14263 return NULL;
14264 }
14265
14266
14267 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14268 PyObject *resultobj = 0;
14269 wxJoystick *arg1 = (wxJoystick *) 0 ;
14270 int result;
14271 void *argp1 = 0 ;
14272 int res1 = 0 ;
14273 PyObject *swig_obj[1] ;
14274
14275 if (!args) SWIG_fail;
14276 swig_obj[0] = args;
14277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14278 if (!SWIG_IsOK(res1)) {
14279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14280 }
14281 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 result = (int)(arg1)->GetPOVCTSPosition();
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 resultobj = SWIG_From_int(static_cast< int >(result));
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14296 PyObject *resultobj = 0;
14297 wxJoystick *arg1 = (wxJoystick *) 0 ;
14298 int result;
14299 void *argp1 = 0 ;
14300 int res1 = 0 ;
14301 PyObject *swig_obj[1] ;
14302
14303 if (!args) SWIG_fail;
14304 swig_obj[0] = args;
14305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14306 if (!SWIG_IsOK(res1)) {
14307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14308 }
14309 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14310 {
14311 PyThreadState* __tstate = wxPyBeginAllowThreads();
14312 result = (int)(arg1)->GetRudderPosition();
14313 wxPyEndAllowThreads(__tstate);
14314 if (PyErr_Occurred()) SWIG_fail;
14315 }
14316 resultobj = SWIG_From_int(static_cast< int >(result));
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14324 PyObject *resultobj = 0;
14325 wxJoystick *arg1 = (wxJoystick *) 0 ;
14326 int result;
14327 void *argp1 = 0 ;
14328 int res1 = 0 ;
14329 PyObject *swig_obj[1] ;
14330
14331 if (!args) SWIG_fail;
14332 swig_obj[0] = args;
14333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14334 if (!SWIG_IsOK(res1)) {
14335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14336 }
14337 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 result = (int)(arg1)->GetUPosition();
14341 wxPyEndAllowThreads(__tstate);
14342 if (PyErr_Occurred()) SWIG_fail;
14343 }
14344 resultobj = SWIG_From_int(static_cast< int >(result));
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14352 PyObject *resultobj = 0;
14353 wxJoystick *arg1 = (wxJoystick *) 0 ;
14354 int result;
14355 void *argp1 = 0 ;
14356 int res1 = 0 ;
14357 PyObject *swig_obj[1] ;
14358
14359 if (!args) SWIG_fail;
14360 swig_obj[0] = args;
14361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14362 if (!SWIG_IsOK(res1)) {
14363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14364 }
14365 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (int)(arg1)->GetVPosition();
14369 wxPyEndAllowThreads(__tstate);
14370 if (PyErr_Occurred()) SWIG_fail;
14371 }
14372 resultobj = SWIG_From_int(static_cast< int >(result));
14373 return resultobj;
14374 fail:
14375 return NULL;
14376 }
14377
14378
14379 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14380 PyObject *resultobj = 0;
14381 wxJoystick *arg1 = (wxJoystick *) 0 ;
14382 int result;
14383 void *argp1 = 0 ;
14384 int res1 = 0 ;
14385 PyObject *swig_obj[1] ;
14386
14387 if (!args) SWIG_fail;
14388 swig_obj[0] = args;
14389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14390 if (!SWIG_IsOK(res1)) {
14391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14392 }
14393 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14394 {
14395 PyThreadState* __tstate = wxPyBeginAllowThreads();
14396 result = (int)(arg1)->GetMovementThreshold();
14397 wxPyEndAllowThreads(__tstate);
14398 if (PyErr_Occurred()) SWIG_fail;
14399 }
14400 resultobj = SWIG_From_int(static_cast< int >(result));
14401 return resultobj;
14402 fail:
14403 return NULL;
14404 }
14405
14406
14407 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14408 PyObject *resultobj = 0;
14409 wxJoystick *arg1 = (wxJoystick *) 0 ;
14410 int arg2 ;
14411 void *argp1 = 0 ;
14412 int res1 = 0 ;
14413 int val2 ;
14414 int ecode2 = 0 ;
14415 PyObject * obj0 = 0 ;
14416 PyObject * obj1 = 0 ;
14417 char * kwnames[] = {
14418 (char *) "self",(char *) "threshold", NULL
14419 };
14420
14421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14423 if (!SWIG_IsOK(res1)) {
14424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14425 }
14426 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14427 ecode2 = SWIG_AsVal_int(obj1, &val2);
14428 if (!SWIG_IsOK(ecode2)) {
14429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14430 }
14431 arg2 = static_cast< int >(val2);
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 (arg1)->SetMovementThreshold(arg2);
14435 wxPyEndAllowThreads(__tstate);
14436 if (PyErr_Occurred()) SWIG_fail;
14437 }
14438 resultobj = SWIG_Py_Void();
14439 return resultobj;
14440 fail:
14441 return NULL;
14442 }
14443
14444
14445 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14446 PyObject *resultobj = 0;
14447 wxJoystick *arg1 = (wxJoystick *) 0 ;
14448 bool result;
14449 void *argp1 = 0 ;
14450 int res1 = 0 ;
14451 PyObject *swig_obj[1] ;
14452
14453 if (!args) SWIG_fail;
14454 swig_obj[0] = args;
14455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14456 if (!SWIG_IsOK(res1)) {
14457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14458 }
14459 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14460 {
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 result = (bool)(arg1)->IsOk();
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 {
14467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14468 }
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14476 PyObject *resultobj = 0;
14477 wxJoystick *arg1 = (wxJoystick *) 0 ;
14478 int result;
14479 void *argp1 = 0 ;
14480 int res1 = 0 ;
14481 PyObject *swig_obj[1] ;
14482
14483 if (!args) SWIG_fail;
14484 swig_obj[0] = args;
14485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14486 if (!SWIG_IsOK(res1)) {
14487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14488 }
14489 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14490 {
14491 PyThreadState* __tstate = wxPyBeginAllowThreads();
14492 result = (int)(arg1)->GetNumberJoysticks();
14493 wxPyEndAllowThreads(__tstate);
14494 if (PyErr_Occurred()) SWIG_fail;
14495 }
14496 resultobj = SWIG_From_int(static_cast< int >(result));
14497 return resultobj;
14498 fail:
14499 return NULL;
14500 }
14501
14502
14503 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14504 PyObject *resultobj = 0;
14505 wxJoystick *arg1 = (wxJoystick *) 0 ;
14506 int result;
14507 void *argp1 = 0 ;
14508 int res1 = 0 ;
14509 PyObject *swig_obj[1] ;
14510
14511 if (!args) SWIG_fail;
14512 swig_obj[0] = args;
14513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14514 if (!SWIG_IsOK(res1)) {
14515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14516 }
14517 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14518 {
14519 PyThreadState* __tstate = wxPyBeginAllowThreads();
14520 result = (int)(arg1)->GetManufacturerId();
14521 wxPyEndAllowThreads(__tstate);
14522 if (PyErr_Occurred()) SWIG_fail;
14523 }
14524 resultobj = SWIG_From_int(static_cast< int >(result));
14525 return resultobj;
14526 fail:
14527 return NULL;
14528 }
14529
14530
14531 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14532 PyObject *resultobj = 0;
14533 wxJoystick *arg1 = (wxJoystick *) 0 ;
14534 int result;
14535 void *argp1 = 0 ;
14536 int res1 = 0 ;
14537 PyObject *swig_obj[1] ;
14538
14539 if (!args) SWIG_fail;
14540 swig_obj[0] = args;
14541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14542 if (!SWIG_IsOK(res1)) {
14543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14544 }
14545 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 result = (int)(arg1)->GetProductId();
14549 wxPyEndAllowThreads(__tstate);
14550 if (PyErr_Occurred()) SWIG_fail;
14551 }
14552 resultobj = SWIG_From_int(static_cast< int >(result));
14553 return resultobj;
14554 fail:
14555 return NULL;
14556 }
14557
14558
14559 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14560 PyObject *resultobj = 0;
14561 wxJoystick *arg1 = (wxJoystick *) 0 ;
14562 wxString result;
14563 void *argp1 = 0 ;
14564 int res1 = 0 ;
14565 PyObject *swig_obj[1] ;
14566
14567 if (!args) SWIG_fail;
14568 swig_obj[0] = args;
14569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14570 if (!SWIG_IsOK(res1)) {
14571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14572 }
14573 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14574 {
14575 PyThreadState* __tstate = wxPyBeginAllowThreads();
14576 result = (arg1)->GetProductName();
14577 wxPyEndAllowThreads(__tstate);
14578 if (PyErr_Occurred()) SWIG_fail;
14579 }
14580 {
14581 #if wxUSE_UNICODE
14582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14583 #else
14584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14585 #endif
14586 }
14587 return resultobj;
14588 fail:
14589 return NULL;
14590 }
14591
14592
14593 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14594 PyObject *resultobj = 0;
14595 wxJoystick *arg1 = (wxJoystick *) 0 ;
14596 int result;
14597 void *argp1 = 0 ;
14598 int res1 = 0 ;
14599 PyObject *swig_obj[1] ;
14600
14601 if (!args) SWIG_fail;
14602 swig_obj[0] = args;
14603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14604 if (!SWIG_IsOK(res1)) {
14605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14606 }
14607 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14608 {
14609 PyThreadState* __tstate = wxPyBeginAllowThreads();
14610 result = (int)(arg1)->GetXMin();
14611 wxPyEndAllowThreads(__tstate);
14612 if (PyErr_Occurred()) SWIG_fail;
14613 }
14614 resultobj = SWIG_From_int(static_cast< int >(result));
14615 return resultobj;
14616 fail:
14617 return NULL;
14618 }
14619
14620
14621 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14622 PyObject *resultobj = 0;
14623 wxJoystick *arg1 = (wxJoystick *) 0 ;
14624 int result;
14625 void *argp1 = 0 ;
14626 int res1 = 0 ;
14627 PyObject *swig_obj[1] ;
14628
14629 if (!args) SWIG_fail;
14630 swig_obj[0] = args;
14631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14632 if (!SWIG_IsOK(res1)) {
14633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14634 }
14635 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14636 {
14637 PyThreadState* __tstate = wxPyBeginAllowThreads();
14638 result = (int)(arg1)->GetYMin();
14639 wxPyEndAllowThreads(__tstate);
14640 if (PyErr_Occurred()) SWIG_fail;
14641 }
14642 resultobj = SWIG_From_int(static_cast< int >(result));
14643 return resultobj;
14644 fail:
14645 return NULL;
14646 }
14647
14648
14649 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14650 PyObject *resultobj = 0;
14651 wxJoystick *arg1 = (wxJoystick *) 0 ;
14652 int result;
14653 void *argp1 = 0 ;
14654 int res1 = 0 ;
14655 PyObject *swig_obj[1] ;
14656
14657 if (!args) SWIG_fail;
14658 swig_obj[0] = args;
14659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14660 if (!SWIG_IsOK(res1)) {
14661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14662 }
14663 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14664 {
14665 PyThreadState* __tstate = wxPyBeginAllowThreads();
14666 result = (int)(arg1)->GetZMin();
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 resultobj = SWIG_From_int(static_cast< int >(result));
14671 return resultobj;
14672 fail:
14673 return NULL;
14674 }
14675
14676
14677 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14678 PyObject *resultobj = 0;
14679 wxJoystick *arg1 = (wxJoystick *) 0 ;
14680 int result;
14681 void *argp1 = 0 ;
14682 int res1 = 0 ;
14683 PyObject *swig_obj[1] ;
14684
14685 if (!args) SWIG_fail;
14686 swig_obj[0] = args;
14687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14690 }
14691 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 result = (int)(arg1)->GetXMax();
14695 wxPyEndAllowThreads(__tstate);
14696 if (PyErr_Occurred()) SWIG_fail;
14697 }
14698 resultobj = SWIG_From_int(static_cast< int >(result));
14699 return resultobj;
14700 fail:
14701 return NULL;
14702 }
14703
14704
14705 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14706 PyObject *resultobj = 0;
14707 wxJoystick *arg1 = (wxJoystick *) 0 ;
14708 int result;
14709 void *argp1 = 0 ;
14710 int res1 = 0 ;
14711 PyObject *swig_obj[1] ;
14712
14713 if (!args) SWIG_fail;
14714 swig_obj[0] = args;
14715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14716 if (!SWIG_IsOK(res1)) {
14717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14718 }
14719 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14720 {
14721 PyThreadState* __tstate = wxPyBeginAllowThreads();
14722 result = (int)(arg1)->GetYMax();
14723 wxPyEndAllowThreads(__tstate);
14724 if (PyErr_Occurred()) SWIG_fail;
14725 }
14726 resultobj = SWIG_From_int(static_cast< int >(result));
14727 return resultobj;
14728 fail:
14729 return NULL;
14730 }
14731
14732
14733 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14734 PyObject *resultobj = 0;
14735 wxJoystick *arg1 = (wxJoystick *) 0 ;
14736 int result;
14737 void *argp1 = 0 ;
14738 int res1 = 0 ;
14739 PyObject *swig_obj[1] ;
14740
14741 if (!args) SWIG_fail;
14742 swig_obj[0] = args;
14743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14744 if (!SWIG_IsOK(res1)) {
14745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14746 }
14747 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14748 {
14749 PyThreadState* __tstate = wxPyBeginAllowThreads();
14750 result = (int)(arg1)->GetZMax();
14751 wxPyEndAllowThreads(__tstate);
14752 if (PyErr_Occurred()) SWIG_fail;
14753 }
14754 resultobj = SWIG_From_int(static_cast< int >(result));
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14762 PyObject *resultobj = 0;
14763 wxJoystick *arg1 = (wxJoystick *) 0 ;
14764 int result;
14765 void *argp1 = 0 ;
14766 int res1 = 0 ;
14767 PyObject *swig_obj[1] ;
14768
14769 if (!args) SWIG_fail;
14770 swig_obj[0] = args;
14771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14772 if (!SWIG_IsOK(res1)) {
14773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14774 }
14775 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14776 {
14777 PyThreadState* __tstate = wxPyBeginAllowThreads();
14778 result = (int)(arg1)->GetNumberButtons();
14779 wxPyEndAllowThreads(__tstate);
14780 if (PyErr_Occurred()) SWIG_fail;
14781 }
14782 resultobj = SWIG_From_int(static_cast< int >(result));
14783 return resultobj;
14784 fail:
14785 return NULL;
14786 }
14787
14788
14789 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14790 PyObject *resultobj = 0;
14791 wxJoystick *arg1 = (wxJoystick *) 0 ;
14792 int result;
14793 void *argp1 = 0 ;
14794 int res1 = 0 ;
14795 PyObject *swig_obj[1] ;
14796
14797 if (!args) SWIG_fail;
14798 swig_obj[0] = args;
14799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14800 if (!SWIG_IsOK(res1)) {
14801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14802 }
14803 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14804 {
14805 PyThreadState* __tstate = wxPyBeginAllowThreads();
14806 result = (int)(arg1)->GetNumberAxes();
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 resultobj = SWIG_From_int(static_cast< int >(result));
14811 return resultobj;
14812 fail:
14813 return NULL;
14814 }
14815
14816
14817 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14818 PyObject *resultobj = 0;
14819 wxJoystick *arg1 = (wxJoystick *) 0 ;
14820 int result;
14821 void *argp1 = 0 ;
14822 int res1 = 0 ;
14823 PyObject *swig_obj[1] ;
14824
14825 if (!args) SWIG_fail;
14826 swig_obj[0] = args;
14827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14828 if (!SWIG_IsOK(res1)) {
14829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14830 }
14831 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14832 {
14833 PyThreadState* __tstate = wxPyBeginAllowThreads();
14834 result = (int)(arg1)->GetMaxButtons();
14835 wxPyEndAllowThreads(__tstate);
14836 if (PyErr_Occurred()) SWIG_fail;
14837 }
14838 resultobj = SWIG_From_int(static_cast< int >(result));
14839 return resultobj;
14840 fail:
14841 return NULL;
14842 }
14843
14844
14845 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14846 PyObject *resultobj = 0;
14847 wxJoystick *arg1 = (wxJoystick *) 0 ;
14848 int result;
14849 void *argp1 = 0 ;
14850 int res1 = 0 ;
14851 PyObject *swig_obj[1] ;
14852
14853 if (!args) SWIG_fail;
14854 swig_obj[0] = args;
14855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14856 if (!SWIG_IsOK(res1)) {
14857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14858 }
14859 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 result = (int)(arg1)->GetMaxAxes();
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 resultobj = SWIG_From_int(static_cast< int >(result));
14867 return resultobj;
14868 fail:
14869 return NULL;
14870 }
14871
14872
14873 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14874 PyObject *resultobj = 0;
14875 wxJoystick *arg1 = (wxJoystick *) 0 ;
14876 int result;
14877 void *argp1 = 0 ;
14878 int res1 = 0 ;
14879 PyObject *swig_obj[1] ;
14880
14881 if (!args) SWIG_fail;
14882 swig_obj[0] = args;
14883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14884 if (!SWIG_IsOK(res1)) {
14885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14886 }
14887 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14888 {
14889 PyThreadState* __tstate = wxPyBeginAllowThreads();
14890 result = (int)(arg1)->GetPollingMin();
14891 wxPyEndAllowThreads(__tstate);
14892 if (PyErr_Occurred()) SWIG_fail;
14893 }
14894 resultobj = SWIG_From_int(static_cast< int >(result));
14895 return resultobj;
14896 fail:
14897 return NULL;
14898 }
14899
14900
14901 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14902 PyObject *resultobj = 0;
14903 wxJoystick *arg1 = (wxJoystick *) 0 ;
14904 int result;
14905 void *argp1 = 0 ;
14906 int res1 = 0 ;
14907 PyObject *swig_obj[1] ;
14908
14909 if (!args) SWIG_fail;
14910 swig_obj[0] = args;
14911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14912 if (!SWIG_IsOK(res1)) {
14913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14914 }
14915 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (int)(arg1)->GetPollingMax();
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 resultobj = SWIG_From_int(static_cast< int >(result));
14923 return resultobj;
14924 fail:
14925 return NULL;
14926 }
14927
14928
14929 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14930 PyObject *resultobj = 0;
14931 wxJoystick *arg1 = (wxJoystick *) 0 ;
14932 int result;
14933 void *argp1 = 0 ;
14934 int res1 = 0 ;
14935 PyObject *swig_obj[1] ;
14936
14937 if (!args) SWIG_fail;
14938 swig_obj[0] = args;
14939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14940 if (!SWIG_IsOK(res1)) {
14941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14942 }
14943 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14944 {
14945 PyThreadState* __tstate = wxPyBeginAllowThreads();
14946 result = (int)(arg1)->GetRudderMin();
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 resultobj = SWIG_From_int(static_cast< int >(result));
14951 return resultobj;
14952 fail:
14953 return NULL;
14954 }
14955
14956
14957 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14958 PyObject *resultobj = 0;
14959 wxJoystick *arg1 = (wxJoystick *) 0 ;
14960 int result;
14961 void *argp1 = 0 ;
14962 int res1 = 0 ;
14963 PyObject *swig_obj[1] ;
14964
14965 if (!args) SWIG_fail;
14966 swig_obj[0] = args;
14967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14968 if (!SWIG_IsOK(res1)) {
14969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14970 }
14971 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14972 {
14973 PyThreadState* __tstate = wxPyBeginAllowThreads();
14974 result = (int)(arg1)->GetRudderMax();
14975 wxPyEndAllowThreads(__tstate);
14976 if (PyErr_Occurred()) SWIG_fail;
14977 }
14978 resultobj = SWIG_From_int(static_cast< int >(result));
14979 return resultobj;
14980 fail:
14981 return NULL;
14982 }
14983
14984
14985 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14986 PyObject *resultobj = 0;
14987 wxJoystick *arg1 = (wxJoystick *) 0 ;
14988 int result;
14989 void *argp1 = 0 ;
14990 int res1 = 0 ;
14991 PyObject *swig_obj[1] ;
14992
14993 if (!args) SWIG_fail;
14994 swig_obj[0] = args;
14995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14996 if (!SWIG_IsOK(res1)) {
14997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14998 }
14999 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 result = (int)(arg1)->GetUMin();
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 resultobj = SWIG_From_int(static_cast< int >(result));
15007 return resultobj;
15008 fail:
15009 return NULL;
15010 }
15011
15012
15013 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15014 PyObject *resultobj = 0;
15015 wxJoystick *arg1 = (wxJoystick *) 0 ;
15016 int result;
15017 void *argp1 = 0 ;
15018 int res1 = 0 ;
15019 PyObject *swig_obj[1] ;
15020
15021 if (!args) SWIG_fail;
15022 swig_obj[0] = args;
15023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15024 if (!SWIG_IsOK(res1)) {
15025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15026 }
15027 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15028 {
15029 PyThreadState* __tstate = wxPyBeginAllowThreads();
15030 result = (int)(arg1)->GetUMax();
15031 wxPyEndAllowThreads(__tstate);
15032 if (PyErr_Occurred()) SWIG_fail;
15033 }
15034 resultobj = SWIG_From_int(static_cast< int >(result));
15035 return resultobj;
15036 fail:
15037 return NULL;
15038 }
15039
15040
15041 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15042 PyObject *resultobj = 0;
15043 wxJoystick *arg1 = (wxJoystick *) 0 ;
15044 int result;
15045 void *argp1 = 0 ;
15046 int res1 = 0 ;
15047 PyObject *swig_obj[1] ;
15048
15049 if (!args) SWIG_fail;
15050 swig_obj[0] = args;
15051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15052 if (!SWIG_IsOK(res1)) {
15053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15054 }
15055 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 result = (int)(arg1)->GetVMin();
15059 wxPyEndAllowThreads(__tstate);
15060 if (PyErr_Occurred()) SWIG_fail;
15061 }
15062 resultobj = SWIG_From_int(static_cast< int >(result));
15063 return resultobj;
15064 fail:
15065 return NULL;
15066 }
15067
15068
15069 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15070 PyObject *resultobj = 0;
15071 wxJoystick *arg1 = (wxJoystick *) 0 ;
15072 int result;
15073 void *argp1 = 0 ;
15074 int res1 = 0 ;
15075 PyObject *swig_obj[1] ;
15076
15077 if (!args) SWIG_fail;
15078 swig_obj[0] = args;
15079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15080 if (!SWIG_IsOK(res1)) {
15081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15082 }
15083 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (int)(arg1)->GetVMax();
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 resultobj = SWIG_From_int(static_cast< int >(result));
15091 return resultobj;
15092 fail:
15093 return NULL;
15094 }
15095
15096
15097 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15098 PyObject *resultobj = 0;
15099 wxJoystick *arg1 = (wxJoystick *) 0 ;
15100 bool result;
15101 void *argp1 = 0 ;
15102 int res1 = 0 ;
15103 PyObject *swig_obj[1] ;
15104
15105 if (!args) SWIG_fail;
15106 swig_obj[0] = args;
15107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15108 if (!SWIG_IsOK(res1)) {
15109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
15110 }
15111 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15112 {
15113 PyThreadState* __tstate = wxPyBeginAllowThreads();
15114 result = (bool)(arg1)->HasRudder();
15115 wxPyEndAllowThreads(__tstate);
15116 if (PyErr_Occurred()) SWIG_fail;
15117 }
15118 {
15119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15120 }
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15128 PyObject *resultobj = 0;
15129 wxJoystick *arg1 = (wxJoystick *) 0 ;
15130 bool result;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 PyObject *swig_obj[1] ;
15134
15135 if (!args) SWIG_fail;
15136 swig_obj[0] = args;
15137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15138 if (!SWIG_IsOK(res1)) {
15139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
15140 }
15141 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15142 {
15143 PyThreadState* __tstate = wxPyBeginAllowThreads();
15144 result = (bool)(arg1)->HasZ();
15145 wxPyEndAllowThreads(__tstate);
15146 if (PyErr_Occurred()) SWIG_fail;
15147 }
15148 {
15149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15150 }
15151 return resultobj;
15152 fail:
15153 return NULL;
15154 }
15155
15156
15157 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15158 PyObject *resultobj = 0;
15159 wxJoystick *arg1 = (wxJoystick *) 0 ;
15160 bool result;
15161 void *argp1 = 0 ;
15162 int res1 = 0 ;
15163 PyObject *swig_obj[1] ;
15164
15165 if (!args) SWIG_fail;
15166 swig_obj[0] = args;
15167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15168 if (!SWIG_IsOK(res1)) {
15169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
15170 }
15171 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 result = (bool)(arg1)->HasU();
15175 wxPyEndAllowThreads(__tstate);
15176 if (PyErr_Occurred()) SWIG_fail;
15177 }
15178 {
15179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15180 }
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15188 PyObject *resultobj = 0;
15189 wxJoystick *arg1 = (wxJoystick *) 0 ;
15190 bool result;
15191 void *argp1 = 0 ;
15192 int res1 = 0 ;
15193 PyObject *swig_obj[1] ;
15194
15195 if (!args) SWIG_fail;
15196 swig_obj[0] = args;
15197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15198 if (!SWIG_IsOK(res1)) {
15199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15200 }
15201 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15202 {
15203 PyThreadState* __tstate = wxPyBeginAllowThreads();
15204 result = (bool)(arg1)->HasV();
15205 wxPyEndAllowThreads(__tstate);
15206 if (PyErr_Occurred()) SWIG_fail;
15207 }
15208 {
15209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15210 }
15211 return resultobj;
15212 fail:
15213 return NULL;
15214 }
15215
15216
15217 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15218 PyObject *resultobj = 0;
15219 wxJoystick *arg1 = (wxJoystick *) 0 ;
15220 bool result;
15221 void *argp1 = 0 ;
15222 int res1 = 0 ;
15223 PyObject *swig_obj[1] ;
15224
15225 if (!args) SWIG_fail;
15226 swig_obj[0] = args;
15227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15228 if (!SWIG_IsOK(res1)) {
15229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15230 }
15231 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15232 {
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 result = (bool)(arg1)->HasPOV();
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 {
15239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15240 }
15241 return resultobj;
15242 fail:
15243 return NULL;
15244 }
15245
15246
15247 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15248 PyObject *resultobj = 0;
15249 wxJoystick *arg1 = (wxJoystick *) 0 ;
15250 bool result;
15251 void *argp1 = 0 ;
15252 int res1 = 0 ;
15253 PyObject *swig_obj[1] ;
15254
15255 if (!args) SWIG_fail;
15256 swig_obj[0] = args;
15257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15258 if (!SWIG_IsOK(res1)) {
15259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15260 }
15261 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15262 {
15263 PyThreadState* __tstate = wxPyBeginAllowThreads();
15264 result = (bool)(arg1)->HasPOV4Dir();
15265 wxPyEndAllowThreads(__tstate);
15266 if (PyErr_Occurred()) SWIG_fail;
15267 }
15268 {
15269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15270 }
15271 return resultobj;
15272 fail:
15273 return NULL;
15274 }
15275
15276
15277 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15278 PyObject *resultobj = 0;
15279 wxJoystick *arg1 = (wxJoystick *) 0 ;
15280 bool 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_wxJoystick, 0 | 0 );
15288 if (!SWIG_IsOK(res1)) {
15289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15290 }
15291 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15292 {
15293 PyThreadState* __tstate = wxPyBeginAllowThreads();
15294 result = (bool)(arg1)->HasPOVCTS();
15295 wxPyEndAllowThreads(__tstate);
15296 if (PyErr_Occurred()) SWIG_fail;
15297 }
15298 {
15299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15300 }
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15308 PyObject *resultobj = 0;
15309 wxJoystick *arg1 = (wxJoystick *) 0 ;
15310 wxWindow *arg2 = (wxWindow *) 0 ;
15311 int arg3 = (int) 0 ;
15312 bool result;
15313 void *argp1 = 0 ;
15314 int res1 = 0 ;
15315 void *argp2 = 0 ;
15316 int res2 = 0 ;
15317 int val3 ;
15318 int ecode3 = 0 ;
15319 PyObject * obj0 = 0 ;
15320 PyObject * obj1 = 0 ;
15321 PyObject * obj2 = 0 ;
15322 char * kwnames[] = {
15323 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15324 };
15325
15326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15328 if (!SWIG_IsOK(res1)) {
15329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15330 }
15331 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15332 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15333 if (!SWIG_IsOK(res2)) {
15334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15335 }
15336 arg2 = reinterpret_cast< wxWindow * >(argp2);
15337 if (obj2) {
15338 ecode3 = SWIG_AsVal_int(obj2, &val3);
15339 if (!SWIG_IsOK(ecode3)) {
15340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15341 }
15342 arg3 = static_cast< int >(val3);
15343 }
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 result = (bool)(arg1)->SetCapture(arg2,arg3);
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 {
15351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15352 }
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15360 PyObject *resultobj = 0;
15361 wxJoystick *arg1 = (wxJoystick *) 0 ;
15362 bool result;
15363 void *argp1 = 0 ;
15364 int res1 = 0 ;
15365 PyObject *swig_obj[1] ;
15366
15367 if (!args) SWIG_fail;
15368 swig_obj[0] = args;
15369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15370 if (!SWIG_IsOK(res1)) {
15371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15372 }
15373 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15374 {
15375 PyThreadState* __tstate = wxPyBeginAllowThreads();
15376 result = (bool)(arg1)->ReleaseCapture();
15377 wxPyEndAllowThreads(__tstate);
15378 if (PyErr_Occurred()) SWIG_fail;
15379 }
15380 {
15381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15382 }
15383 return resultobj;
15384 fail:
15385 return NULL;
15386 }
15387
15388
15389 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15390 PyObject *obj;
15391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15392 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15393 return SWIG_Py_Void();
15394 }
15395
15396 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15397 return SWIG_Python_InitShadowInstance(args);
15398 }
15399
15400 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15401 PyObject *resultobj = 0;
15402 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15403 int arg2 = (int) 0 ;
15404 int arg3 = (int) wxJOYSTICK1 ;
15405 int arg4 = (int) 0 ;
15406 wxJoystickEvent *result = 0 ;
15407 int val1 ;
15408 int ecode1 = 0 ;
15409 int val2 ;
15410 int ecode2 = 0 ;
15411 int val3 ;
15412 int ecode3 = 0 ;
15413 int val4 ;
15414 int ecode4 = 0 ;
15415 PyObject * obj0 = 0 ;
15416 PyObject * obj1 = 0 ;
15417 PyObject * obj2 = 0 ;
15418 PyObject * obj3 = 0 ;
15419 char * kwnames[] = {
15420 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15421 };
15422
15423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15424 if (obj0) {
15425 ecode1 = SWIG_AsVal_int(obj0, &val1);
15426 if (!SWIG_IsOK(ecode1)) {
15427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15428 }
15429 arg1 = static_cast< wxEventType >(val1);
15430 }
15431 if (obj1) {
15432 ecode2 = SWIG_AsVal_int(obj1, &val2);
15433 if (!SWIG_IsOK(ecode2)) {
15434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15435 }
15436 arg2 = static_cast< int >(val2);
15437 }
15438 if (obj2) {
15439 ecode3 = SWIG_AsVal_int(obj2, &val3);
15440 if (!SWIG_IsOK(ecode3)) {
15441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15442 }
15443 arg3 = static_cast< int >(val3);
15444 }
15445 if (obj3) {
15446 ecode4 = SWIG_AsVal_int(obj3, &val4);
15447 if (!SWIG_IsOK(ecode4)) {
15448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15449 }
15450 arg4 = static_cast< int >(val4);
15451 }
15452 {
15453 PyThreadState* __tstate = wxPyBeginAllowThreads();
15454 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15459 return resultobj;
15460 fail:
15461 return NULL;
15462 }
15463
15464
15465 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15466 PyObject *resultobj = 0;
15467 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15468 wxPoint result;
15469 void *argp1 = 0 ;
15470 int res1 = 0 ;
15471 PyObject *swig_obj[1] ;
15472
15473 if (!args) SWIG_fail;
15474 swig_obj[0] = args;
15475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15476 if (!SWIG_IsOK(res1)) {
15477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15478 }
15479 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15480 {
15481 PyThreadState* __tstate = wxPyBeginAllowThreads();
15482 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15483 wxPyEndAllowThreads(__tstate);
15484 if (PyErr_Occurred()) SWIG_fail;
15485 }
15486 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15487 return resultobj;
15488 fail:
15489 return NULL;
15490 }
15491
15492
15493 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15494 PyObject *resultobj = 0;
15495 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15496 int result;
15497 void *argp1 = 0 ;
15498 int res1 = 0 ;
15499 PyObject *swig_obj[1] ;
15500
15501 if (!args) SWIG_fail;
15502 swig_obj[0] = args;
15503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15504 if (!SWIG_IsOK(res1)) {
15505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15506 }
15507 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 resultobj = SWIG_From_int(static_cast< int >(result));
15515 return resultobj;
15516 fail:
15517 return NULL;
15518 }
15519
15520
15521 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15522 PyObject *resultobj = 0;
15523 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15524 int result;
15525 void *argp1 = 0 ;
15526 int res1 = 0 ;
15527 PyObject *swig_obj[1] ;
15528
15529 if (!args) SWIG_fail;
15530 swig_obj[0] = args;
15531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15532 if (!SWIG_IsOK(res1)) {
15533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15534 }
15535 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15536 {
15537 PyThreadState* __tstate = wxPyBeginAllowThreads();
15538 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15539 wxPyEndAllowThreads(__tstate);
15540 if (PyErr_Occurred()) SWIG_fail;
15541 }
15542 resultobj = SWIG_From_int(static_cast< int >(result));
15543 return resultobj;
15544 fail:
15545 return NULL;
15546 }
15547
15548
15549 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15550 PyObject *resultobj = 0;
15551 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15552 int result;
15553 void *argp1 = 0 ;
15554 int res1 = 0 ;
15555 PyObject *swig_obj[1] ;
15556
15557 if (!args) SWIG_fail;
15558 swig_obj[0] = args;
15559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15560 if (!SWIG_IsOK(res1)) {
15561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15562 }
15563 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15564 {
15565 PyThreadState* __tstate = wxPyBeginAllowThreads();
15566 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15567 wxPyEndAllowThreads(__tstate);
15568 if (PyErr_Occurred()) SWIG_fail;
15569 }
15570 resultobj = SWIG_From_int(static_cast< int >(result));
15571 return resultobj;
15572 fail:
15573 return NULL;
15574 }
15575
15576
15577 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15578 PyObject *resultobj = 0;
15579 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15580 int result;
15581 void *argp1 = 0 ;
15582 int res1 = 0 ;
15583 PyObject *swig_obj[1] ;
15584
15585 if (!args) SWIG_fail;
15586 swig_obj[0] = args;
15587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15588 if (!SWIG_IsOK(res1)) {
15589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15590 }
15591 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15595 wxPyEndAllowThreads(__tstate);
15596 if (PyErr_Occurred()) SWIG_fail;
15597 }
15598 resultobj = SWIG_From_int(static_cast< int >(result));
15599 return resultobj;
15600 fail:
15601 return NULL;
15602 }
15603
15604
15605 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15606 PyObject *resultobj = 0;
15607 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15608 int arg2 ;
15609 void *argp1 = 0 ;
15610 int res1 = 0 ;
15611 int val2 ;
15612 int ecode2 = 0 ;
15613 PyObject * obj0 = 0 ;
15614 PyObject * obj1 = 0 ;
15615 char * kwnames[] = {
15616 (char *) "self",(char *) "stick", NULL
15617 };
15618
15619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15621 if (!SWIG_IsOK(res1)) {
15622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15623 }
15624 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15625 ecode2 = SWIG_AsVal_int(obj1, &val2);
15626 if (!SWIG_IsOK(ecode2)) {
15627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15628 }
15629 arg2 = static_cast< int >(val2);
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 (arg1)->SetJoystick(arg2);
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 resultobj = SWIG_Py_Void();
15637 return resultobj;
15638 fail:
15639 return NULL;
15640 }
15641
15642
15643 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15644 PyObject *resultobj = 0;
15645 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15646 int arg2 ;
15647 void *argp1 = 0 ;
15648 int res1 = 0 ;
15649 int val2 ;
15650 int ecode2 = 0 ;
15651 PyObject * obj0 = 0 ;
15652 PyObject * obj1 = 0 ;
15653 char * kwnames[] = {
15654 (char *) "self",(char *) "state", NULL
15655 };
15656
15657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15661 }
15662 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15663 ecode2 = SWIG_AsVal_int(obj1, &val2);
15664 if (!SWIG_IsOK(ecode2)) {
15665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15666 }
15667 arg2 = static_cast< int >(val2);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 (arg1)->SetButtonState(arg2);
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = SWIG_Py_Void();
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj = 0;
15683 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15684 int arg2 ;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 int val2 ;
15688 int ecode2 = 0 ;
15689 PyObject * obj0 = 0 ;
15690 PyObject * obj1 = 0 ;
15691 char * kwnames[] = {
15692 (char *) "self",(char *) "change", NULL
15693 };
15694
15695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15697 if (!SWIG_IsOK(res1)) {
15698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15699 }
15700 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15701 ecode2 = SWIG_AsVal_int(obj1, &val2);
15702 if (!SWIG_IsOK(ecode2)) {
15703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15704 }
15705 arg2 = static_cast< int >(val2);
15706 {
15707 PyThreadState* __tstate = wxPyBeginAllowThreads();
15708 (arg1)->SetButtonChange(arg2);
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 resultobj = SWIG_Py_Void();
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15720 PyObject *resultobj = 0;
15721 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15722 wxPoint *arg2 = 0 ;
15723 void *argp1 = 0 ;
15724 int res1 = 0 ;
15725 wxPoint temp2 ;
15726 PyObject * obj0 = 0 ;
15727 PyObject * obj1 = 0 ;
15728 char * kwnames[] = {
15729 (char *) "self",(char *) "pos", NULL
15730 };
15731
15732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15734 if (!SWIG_IsOK(res1)) {
15735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15736 }
15737 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15738 {
15739 arg2 = &temp2;
15740 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15741 }
15742 {
15743 PyThreadState* __tstate = wxPyBeginAllowThreads();
15744 (arg1)->SetPosition((wxPoint const &)*arg2);
15745 wxPyEndAllowThreads(__tstate);
15746 if (PyErr_Occurred()) SWIG_fail;
15747 }
15748 resultobj = SWIG_Py_Void();
15749 return resultobj;
15750 fail:
15751 return NULL;
15752 }
15753
15754
15755 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15756 PyObject *resultobj = 0;
15757 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15758 int arg2 ;
15759 void *argp1 = 0 ;
15760 int res1 = 0 ;
15761 int val2 ;
15762 int ecode2 = 0 ;
15763 PyObject * obj0 = 0 ;
15764 PyObject * obj1 = 0 ;
15765 char * kwnames[] = {
15766 (char *) "self",(char *) "zPos", NULL
15767 };
15768
15769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15771 if (!SWIG_IsOK(res1)) {
15772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15773 }
15774 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15775 ecode2 = SWIG_AsVal_int(obj1, &val2);
15776 if (!SWIG_IsOK(ecode2)) {
15777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15778 }
15779 arg2 = static_cast< int >(val2);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 (arg1)->SetZPosition(arg2);
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_Py_Void();
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15796 bool result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15806 }
15807 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 {
15815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15816 }
15817 return resultobj;
15818 fail:
15819 return NULL;
15820 }
15821
15822
15823 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15824 PyObject *resultobj = 0;
15825 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15826 bool result;
15827 void *argp1 = 0 ;
15828 int res1 = 0 ;
15829 PyObject *swig_obj[1] ;
15830
15831 if (!args) SWIG_fail;
15832 swig_obj[0] = args;
15833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15834 if (!SWIG_IsOK(res1)) {
15835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15836 }
15837 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15838 {
15839 PyThreadState* __tstate = wxPyBeginAllowThreads();
15840 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15841 wxPyEndAllowThreads(__tstate);
15842 if (PyErr_Occurred()) SWIG_fail;
15843 }
15844 {
15845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15846 }
15847 return resultobj;
15848 fail:
15849 return NULL;
15850 }
15851
15852
15853 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15854 PyObject *resultobj = 0;
15855 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15856 bool result;
15857 void *argp1 = 0 ;
15858 int res1 = 0 ;
15859 PyObject *swig_obj[1] ;
15860
15861 if (!args) SWIG_fail;
15862 swig_obj[0] = args;
15863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15864 if (!SWIG_IsOK(res1)) {
15865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15866 }
15867 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15868 {
15869 PyThreadState* __tstate = wxPyBeginAllowThreads();
15870 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15871 wxPyEndAllowThreads(__tstate);
15872 if (PyErr_Occurred()) SWIG_fail;
15873 }
15874 {
15875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15876 }
15877 return resultobj;
15878 fail:
15879 return NULL;
15880 }
15881
15882
15883 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15884 PyObject *resultobj = 0;
15885 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15886 int arg2 = (int) wxJOY_BUTTON_ANY ;
15887 bool result;
15888 void *argp1 = 0 ;
15889 int res1 = 0 ;
15890 int val2 ;
15891 int ecode2 = 0 ;
15892 PyObject * obj0 = 0 ;
15893 PyObject * obj1 = 0 ;
15894 char * kwnames[] = {
15895 (char *) "self",(char *) "but", NULL
15896 };
15897
15898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15900 if (!SWIG_IsOK(res1)) {
15901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15902 }
15903 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15904 if (obj1) {
15905 ecode2 = SWIG_AsVal_int(obj1, &val2);
15906 if (!SWIG_IsOK(ecode2)) {
15907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15908 }
15909 arg2 = static_cast< int >(val2);
15910 }
15911 {
15912 PyThreadState* __tstate = wxPyBeginAllowThreads();
15913 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15914 wxPyEndAllowThreads(__tstate);
15915 if (PyErr_Occurred()) SWIG_fail;
15916 }
15917 {
15918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15919 }
15920 return resultobj;
15921 fail:
15922 return NULL;
15923 }
15924
15925
15926 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15927 PyObject *resultobj = 0;
15928 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15929 int arg2 = (int) wxJOY_BUTTON_ANY ;
15930 bool result;
15931 void *argp1 = 0 ;
15932 int res1 = 0 ;
15933 int val2 ;
15934 int ecode2 = 0 ;
15935 PyObject * obj0 = 0 ;
15936 PyObject * obj1 = 0 ;
15937 char * kwnames[] = {
15938 (char *) "self",(char *) "but", NULL
15939 };
15940
15941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15943 if (!SWIG_IsOK(res1)) {
15944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15945 }
15946 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15947 if (obj1) {
15948 ecode2 = SWIG_AsVal_int(obj1, &val2);
15949 if (!SWIG_IsOK(ecode2)) {
15950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15951 }
15952 arg2 = static_cast< int >(val2);
15953 }
15954 {
15955 PyThreadState* __tstate = wxPyBeginAllowThreads();
15956 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 {
15961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15962 }
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15970 PyObject *resultobj = 0;
15971 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15972 int arg2 = (int) wxJOY_BUTTON_ANY ;
15973 bool result;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 int val2 ;
15977 int ecode2 = 0 ;
15978 PyObject * obj0 = 0 ;
15979 PyObject * obj1 = 0 ;
15980 char * kwnames[] = {
15981 (char *) "self",(char *) "but", NULL
15982 };
15983
15984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15986 if (!SWIG_IsOK(res1)) {
15987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15988 }
15989 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15990 if (obj1) {
15991 ecode2 = SWIG_AsVal_int(obj1, &val2);
15992 if (!SWIG_IsOK(ecode2)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15994 }
15995 arg2 = static_cast< int >(val2);
15996 }
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(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 *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16013 PyObject *obj;
16014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16015 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16016 return SWIG_Py_Void();
16017 }
16018
16019 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16020 return SWIG_Python_InitShadowInstance(args);
16021 }
16022
16023 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj = 0;
16025 wxString const &arg1_defvalue = wxPyEmptyString ;
16026 wxString *arg1 = (wxString *) &arg1_defvalue ;
16027 wxSound *result = 0 ;
16028 bool temp1 = false ;
16029 PyObject * obj0 = 0 ;
16030 char * kwnames[] = {
16031 (char *) "fileName", NULL
16032 };
16033
16034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16035 if (obj0) {
16036 {
16037 arg1 = wxString_in_helper(obj0);
16038 if (arg1 == NULL) SWIG_fail;
16039 temp1 = true;
16040 }
16041 }
16042 {
16043 if (!wxPyCheckForApp()) SWIG_fail;
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16046 wxPyEndAllowThreads(__tstate);
16047 if (PyErr_Occurred()) SWIG_fail;
16048 }
16049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16050 {
16051 if (temp1)
16052 delete arg1;
16053 }
16054 return resultobj;
16055 fail:
16056 {
16057 if (temp1)
16058 delete arg1;
16059 }
16060 return NULL;
16061 }
16062
16063
16064 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj = 0;
16066 PyObject *arg1 = (PyObject *) 0 ;
16067 wxSound *result = 0 ;
16068 PyObject * obj0 = 0 ;
16069 char * kwnames[] = {
16070 (char *) "data", NULL
16071 };
16072
16073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16074 arg1 = obj0;
16075 {
16076 if (!wxPyCheckForApp()) SWIG_fail;
16077 PyThreadState* __tstate = wxPyBeginAllowThreads();
16078 result = (wxSound *)new_wxSound(arg1);
16079 wxPyEndAllowThreads(__tstate);
16080 if (PyErr_Occurred()) SWIG_fail;
16081 }
16082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16083 return resultobj;
16084 fail:
16085 return NULL;
16086 }
16087
16088
16089 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16090 PyObject *resultobj = 0;
16091 wxSound *arg1 = (wxSound *) 0 ;
16092 void *argp1 = 0 ;
16093 int res1 = 0 ;
16094 PyObject *swig_obj[1] ;
16095
16096 if (!args) SWIG_fail;
16097 swig_obj[0] = args;
16098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16099 if (!SWIG_IsOK(res1)) {
16100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16101 }
16102 arg1 = reinterpret_cast< wxSound * >(argp1);
16103 {
16104 PyThreadState* __tstate = wxPyBeginAllowThreads();
16105 delete arg1;
16106
16107 wxPyEndAllowThreads(__tstate);
16108 if (PyErr_Occurred()) SWIG_fail;
16109 }
16110 resultobj = SWIG_Py_Void();
16111 return resultobj;
16112 fail:
16113 return NULL;
16114 }
16115
16116
16117 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16118 PyObject *resultobj = 0;
16119 wxSound *arg1 = (wxSound *) 0 ;
16120 wxString *arg2 = 0 ;
16121 bool result;
16122 void *argp1 = 0 ;
16123 int res1 = 0 ;
16124 bool temp2 = false ;
16125 PyObject * obj0 = 0 ;
16126 PyObject * obj1 = 0 ;
16127 char * kwnames[] = {
16128 (char *) "self",(char *) "fileName", NULL
16129 };
16130
16131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
16132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16133 if (!SWIG_IsOK(res1)) {
16134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
16135 }
16136 arg1 = reinterpret_cast< wxSound * >(argp1);
16137 {
16138 arg2 = wxString_in_helper(obj1);
16139 if (arg2 == NULL) SWIG_fail;
16140 temp2 = true;
16141 }
16142 {
16143 PyThreadState* __tstate = wxPyBeginAllowThreads();
16144 result = (bool)(arg1)->Create((wxString const &)*arg2);
16145 wxPyEndAllowThreads(__tstate);
16146 if (PyErr_Occurred()) SWIG_fail;
16147 }
16148 {
16149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16150 }
16151 {
16152 if (temp2)
16153 delete arg2;
16154 }
16155 return resultobj;
16156 fail:
16157 {
16158 if (temp2)
16159 delete arg2;
16160 }
16161 return NULL;
16162 }
16163
16164
16165 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj = 0;
16167 wxSound *arg1 = (wxSound *) 0 ;
16168 PyObject *arg2 = (PyObject *) 0 ;
16169 bool result;
16170 void *argp1 = 0 ;
16171 int res1 = 0 ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "data", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16182 }
16183 arg1 = reinterpret_cast< wxSound * >(argp1);
16184 arg2 = obj1;
16185 {
16186 PyThreadState* __tstate = wxPyBeginAllowThreads();
16187 result = (bool)wxSound_CreateFromData(arg1,arg2);
16188 wxPyEndAllowThreads(__tstate);
16189 if (PyErr_Occurred()) SWIG_fail;
16190 }
16191 {
16192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16193 }
16194 return resultobj;
16195 fail:
16196 return NULL;
16197 }
16198
16199
16200 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16201 PyObject *resultobj = 0;
16202 wxSound *arg1 = (wxSound *) 0 ;
16203 bool result;
16204 void *argp1 = 0 ;
16205 int res1 = 0 ;
16206 PyObject *swig_obj[1] ;
16207
16208 if (!args) SWIG_fail;
16209 swig_obj[0] = args;
16210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16211 if (!SWIG_IsOK(res1)) {
16212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16213 }
16214 arg1 = reinterpret_cast< wxSound * >(argp1);
16215 {
16216 PyThreadState* __tstate = wxPyBeginAllowThreads();
16217 result = (bool)(arg1)->IsOk();
16218 wxPyEndAllowThreads(__tstate);
16219 if (PyErr_Occurred()) SWIG_fail;
16220 }
16221 {
16222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16223 }
16224 return resultobj;
16225 fail:
16226 return NULL;
16227 }
16228
16229
16230 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16231 PyObject *resultobj = 0;
16232 wxSound *arg1 = (wxSound *) 0 ;
16233 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16234 bool result;
16235 void *argp1 = 0 ;
16236 int res1 = 0 ;
16237 unsigned int val2 ;
16238 int ecode2 = 0 ;
16239 PyObject * obj0 = 0 ;
16240 PyObject * obj1 = 0 ;
16241 char * kwnames[] = {
16242 (char *) "self",(char *) "flags", NULL
16243 };
16244
16245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16247 if (!SWIG_IsOK(res1)) {
16248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16249 }
16250 arg1 = reinterpret_cast< wxSound * >(argp1);
16251 if (obj1) {
16252 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16253 if (!SWIG_IsOK(ecode2)) {
16254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16255 }
16256 arg2 = static_cast< unsigned int >(val2);
16257 }
16258 {
16259 if (!wxPyCheckForApp()) SWIG_fail;
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 result = (bool)((wxSound const *)arg1)->Play(arg2);
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 {
16266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16267 }
16268 return resultobj;
16269 fail:
16270 return NULL;
16271 }
16272
16273
16274 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16275 PyObject *resultobj = 0;
16276 wxString *arg1 = 0 ;
16277 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16278 bool result;
16279 bool temp1 = false ;
16280 unsigned int val2 ;
16281 int ecode2 = 0 ;
16282 PyObject * obj0 = 0 ;
16283 PyObject * obj1 = 0 ;
16284 char * kwnames[] = {
16285 (char *) "filename",(char *) "flags", NULL
16286 };
16287
16288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16289 {
16290 arg1 = wxString_in_helper(obj0);
16291 if (arg1 == NULL) SWIG_fail;
16292 temp1 = true;
16293 }
16294 if (obj1) {
16295 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16296 if (!SWIG_IsOK(ecode2)) {
16297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16298 }
16299 arg2 = static_cast< unsigned int >(val2);
16300 }
16301 {
16302 if (!wxPyCheckForApp()) SWIG_fail;
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 {
16309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16310 }
16311 {
16312 if (temp1)
16313 delete arg1;
16314 }
16315 return resultobj;
16316 fail:
16317 {
16318 if (temp1)
16319 delete arg1;
16320 }
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16326 PyObject *resultobj = 0;
16327
16328 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16329 {
16330 if (!wxPyCheckForApp()) SWIG_fail;
16331 PyThreadState* __tstate = wxPyBeginAllowThreads();
16332 wxSound::Stop();
16333 wxPyEndAllowThreads(__tstate);
16334 if (PyErr_Occurred()) SWIG_fail;
16335 }
16336 resultobj = SWIG_Py_Void();
16337 return resultobj;
16338 fail:
16339 return NULL;
16340 }
16341
16342
16343 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16344 PyObject *obj;
16345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16346 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16347 return SWIG_Py_Void();
16348 }
16349
16350 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16351 return SWIG_Python_InitShadowInstance(args);
16352 }
16353
16354 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16355 PyObject *resultobj = 0;
16356 wxString *arg1 = 0 ;
16357 wxString *arg2 = 0 ;
16358 wxString *arg3 = 0 ;
16359 wxString *arg4 = 0 ;
16360 wxFileTypeInfo *result = 0 ;
16361 bool temp1 = false ;
16362 bool temp2 = false ;
16363 bool temp3 = false ;
16364 bool temp4 = false ;
16365 PyObject * obj0 = 0 ;
16366 PyObject * obj1 = 0 ;
16367 PyObject * obj2 = 0 ;
16368 PyObject * obj3 = 0 ;
16369 char * kwnames[] = {
16370 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16371 };
16372
16373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16374 {
16375 arg1 = wxString_in_helper(obj0);
16376 if (arg1 == NULL) SWIG_fail;
16377 temp1 = true;
16378 }
16379 {
16380 arg2 = wxString_in_helper(obj1);
16381 if (arg2 == NULL) SWIG_fail;
16382 temp2 = true;
16383 }
16384 {
16385 arg3 = wxString_in_helper(obj2);
16386 if (arg3 == NULL) SWIG_fail;
16387 temp3 = true;
16388 }
16389 {
16390 arg4 = wxString_in_helper(obj3);
16391 if (arg4 == NULL) SWIG_fail;
16392 temp4 = true;
16393 }
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16401 {
16402 if (temp1)
16403 delete arg1;
16404 }
16405 {
16406 if (temp2)
16407 delete arg2;
16408 }
16409 {
16410 if (temp3)
16411 delete arg3;
16412 }
16413 {
16414 if (temp4)
16415 delete arg4;
16416 }
16417 return resultobj;
16418 fail:
16419 {
16420 if (temp1)
16421 delete arg1;
16422 }
16423 {
16424 if (temp2)
16425 delete arg2;
16426 }
16427 {
16428 if (temp3)
16429 delete arg3;
16430 }
16431 {
16432 if (temp4)
16433 delete arg4;
16434 }
16435 return NULL;
16436 }
16437
16438
16439 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16440 PyObject *resultobj = 0;
16441 wxArrayString *arg1 = 0 ;
16442 wxFileTypeInfo *result = 0 ;
16443 bool temp1 = false ;
16444 PyObject * obj0 = 0 ;
16445 char * kwnames[] = {
16446 (char *) "sArray", NULL
16447 };
16448
16449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16450 {
16451 if (! PySequence_Check(obj0)) {
16452 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16453 SWIG_fail;
16454 }
16455 arg1 = new wxArrayString;
16456 temp1 = true;
16457 int i, len=PySequence_Length(obj0);
16458 for (i=0; i<len; i++) {
16459 PyObject* item = PySequence_GetItem(obj0, i);
16460 wxString* s = wxString_in_helper(item);
16461 if (PyErr_Occurred()) SWIG_fail;
16462 arg1->Add(*s);
16463 delete s;
16464 Py_DECREF(item);
16465 }
16466 }
16467 {
16468 PyThreadState* __tstate = wxPyBeginAllowThreads();
16469 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16470 wxPyEndAllowThreads(__tstate);
16471 if (PyErr_Occurred()) SWIG_fail;
16472 }
16473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16474 {
16475 if (temp1) delete arg1;
16476 }
16477 return resultobj;
16478 fail:
16479 {
16480 if (temp1) delete arg1;
16481 }
16482 return NULL;
16483 }
16484
16485
16486 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16487 PyObject *resultobj = 0;
16488 wxFileTypeInfo *result = 0 ;
16489
16490 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16494 wxPyEndAllowThreads(__tstate);
16495 if (PyErr_Occurred()) SWIG_fail;
16496 }
16497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16498 return resultobj;
16499 fail:
16500 return NULL;
16501 }
16502
16503
16504 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16505 PyObject *resultobj = 0;
16506 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16507 bool result;
16508 void *argp1 = 0 ;
16509 int res1 = 0 ;
16510 PyObject *swig_obj[1] ;
16511
16512 if (!args) SWIG_fail;
16513 swig_obj[0] = args;
16514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16515 if (!SWIG_IsOK(res1)) {
16516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16517 }
16518 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16522 wxPyEndAllowThreads(__tstate);
16523 if (PyErr_Occurred()) SWIG_fail;
16524 }
16525 {
16526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16527 }
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj = 0;
16536 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16537 wxString *arg2 = 0 ;
16538 int arg3 = (int) 0 ;
16539 void *argp1 = 0 ;
16540 int res1 = 0 ;
16541 bool temp2 = false ;
16542 int val3 ;
16543 int ecode3 = 0 ;
16544 PyObject * obj0 = 0 ;
16545 PyObject * obj1 = 0 ;
16546 PyObject * obj2 = 0 ;
16547 char * kwnames[] = {
16548 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16549 };
16550
16551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16553 if (!SWIG_IsOK(res1)) {
16554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16555 }
16556 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16557 {
16558 arg2 = wxString_in_helper(obj1);
16559 if (arg2 == NULL) SWIG_fail;
16560 temp2 = true;
16561 }
16562 if (obj2) {
16563 ecode3 = SWIG_AsVal_int(obj2, &val3);
16564 if (!SWIG_IsOK(ecode3)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16566 }
16567 arg3 = static_cast< int >(val3);
16568 }
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 resultobj = SWIG_Py_Void();
16576 {
16577 if (temp2)
16578 delete arg2;
16579 }
16580 return resultobj;
16581 fail:
16582 {
16583 if (temp2)
16584 delete arg2;
16585 }
16586 return NULL;
16587 }
16588
16589
16590 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16591 PyObject *resultobj = 0;
16592 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16593 wxString *arg2 = 0 ;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 bool temp2 = false ;
16597 PyObject * obj0 = 0 ;
16598 PyObject * obj1 = 0 ;
16599 char * kwnames[] = {
16600 (char *) "self",(char *) "shortDesc", NULL
16601 };
16602
16603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16605 if (!SWIG_IsOK(res1)) {
16606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16607 }
16608 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16609 {
16610 arg2 = wxString_in_helper(obj1);
16611 if (arg2 == NULL) SWIG_fail;
16612 temp2 = true;
16613 }
16614 {
16615 PyThreadState* __tstate = wxPyBeginAllowThreads();
16616 (arg1)->SetShortDesc((wxString const &)*arg2);
16617 wxPyEndAllowThreads(__tstate);
16618 if (PyErr_Occurred()) SWIG_fail;
16619 }
16620 resultobj = SWIG_Py_Void();
16621 {
16622 if (temp2)
16623 delete arg2;
16624 }
16625 return resultobj;
16626 fail:
16627 {
16628 if (temp2)
16629 delete arg2;
16630 }
16631 return NULL;
16632 }
16633
16634
16635 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16636 PyObject *resultobj = 0;
16637 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16638 wxString *result = 0 ;
16639 void *argp1 = 0 ;
16640 int res1 = 0 ;
16641 PyObject *swig_obj[1] ;
16642
16643 if (!args) SWIG_fail;
16644 swig_obj[0] = args;
16645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16646 if (!SWIG_IsOK(res1)) {
16647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16648 }
16649 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16650 {
16651 PyThreadState* __tstate = wxPyBeginAllowThreads();
16652 {
16653 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16654 result = (wxString *) &_result_ref;
16655 }
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 {
16660 #if wxUSE_UNICODE
16661 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16662 #else
16663 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16664 #endif
16665 }
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16673 PyObject *resultobj = 0;
16674 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16675 wxString *result = 0 ;
16676 void *argp1 = 0 ;
16677 int res1 = 0 ;
16678 PyObject *swig_obj[1] ;
16679
16680 if (!args) SWIG_fail;
16681 swig_obj[0] = args;
16682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16683 if (!SWIG_IsOK(res1)) {
16684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16685 }
16686 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 {
16690 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16691 result = (wxString *) &_result_ref;
16692 }
16693 wxPyEndAllowThreads(__tstate);
16694 if (PyErr_Occurred()) SWIG_fail;
16695 }
16696 {
16697 #if wxUSE_UNICODE
16698 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16699 #else
16700 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16701 #endif
16702 }
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16710 PyObject *resultobj = 0;
16711 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16712 wxString *result = 0 ;
16713 void *argp1 = 0 ;
16714 int res1 = 0 ;
16715 PyObject *swig_obj[1] ;
16716
16717 if (!args) SWIG_fail;
16718 swig_obj[0] = args;
16719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16722 }
16723 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16724 {
16725 PyThreadState* __tstate = wxPyBeginAllowThreads();
16726 {
16727 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16728 result = (wxString *) &_result_ref;
16729 }
16730 wxPyEndAllowThreads(__tstate);
16731 if (PyErr_Occurred()) SWIG_fail;
16732 }
16733 {
16734 #if wxUSE_UNICODE
16735 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16736 #else
16737 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16738 #endif
16739 }
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16747 PyObject *resultobj = 0;
16748 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16749 wxString *result = 0 ;
16750 void *argp1 = 0 ;
16751 int res1 = 0 ;
16752 PyObject *swig_obj[1] ;
16753
16754 if (!args) SWIG_fail;
16755 swig_obj[0] = args;
16756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16757 if (!SWIG_IsOK(res1)) {
16758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16759 }
16760 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 {
16764 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16765 result = (wxString *) &_result_ref;
16766 }
16767 wxPyEndAllowThreads(__tstate);
16768 if (PyErr_Occurred()) SWIG_fail;
16769 }
16770 {
16771 #if wxUSE_UNICODE
16772 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16773 #else
16774 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16775 #endif
16776 }
16777 return resultobj;
16778 fail:
16779 return NULL;
16780 }
16781
16782
16783 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16784 PyObject *resultobj = 0;
16785 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16786 wxString *result = 0 ;
16787 void *argp1 = 0 ;
16788 int res1 = 0 ;
16789 PyObject *swig_obj[1] ;
16790
16791 if (!args) SWIG_fail;
16792 swig_obj[0] = args;
16793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16794 if (!SWIG_IsOK(res1)) {
16795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16796 }
16797 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16798 {
16799 PyThreadState* __tstate = wxPyBeginAllowThreads();
16800 {
16801 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16802 result = (wxString *) &_result_ref;
16803 }
16804 wxPyEndAllowThreads(__tstate);
16805 if (PyErr_Occurred()) SWIG_fail;
16806 }
16807 {
16808 #if wxUSE_UNICODE
16809 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16810 #else
16811 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16812 #endif
16813 }
16814 return resultobj;
16815 fail:
16816 return NULL;
16817 }
16818
16819
16820 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16821 PyObject *resultobj = 0;
16822 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16823 wxArrayString *result = 0 ;
16824 void *argp1 = 0 ;
16825 int res1 = 0 ;
16826 PyObject *swig_obj[1] ;
16827
16828 if (!args) SWIG_fail;
16829 swig_obj[0] = args;
16830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16831 if (!SWIG_IsOK(res1)) {
16832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16833 }
16834 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16835 {
16836 PyThreadState* __tstate = wxPyBeginAllowThreads();
16837 {
16838 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16839 result = (wxArrayString *) &_result_ref;
16840 }
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 {
16845 resultobj = wxArrayString2PyList_helper(*result);
16846 }
16847 return resultobj;
16848 fail:
16849 return NULL;
16850 }
16851
16852
16853 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16854 PyObject *resultobj = 0;
16855 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16856 size_t result;
16857 void *argp1 = 0 ;
16858 int res1 = 0 ;
16859 PyObject *swig_obj[1] ;
16860
16861 if (!args) SWIG_fail;
16862 swig_obj[0] = args;
16863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16864 if (!SWIG_IsOK(res1)) {
16865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16866 }
16867 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16868 {
16869 PyThreadState* __tstate = wxPyBeginAllowThreads();
16870 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16871 wxPyEndAllowThreads(__tstate);
16872 if (PyErr_Occurred()) SWIG_fail;
16873 }
16874 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16882 PyObject *resultobj = 0;
16883 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16884 wxString *result = 0 ;
16885 void *argp1 = 0 ;
16886 int res1 = 0 ;
16887 PyObject *swig_obj[1] ;
16888
16889 if (!args) SWIG_fail;
16890 swig_obj[0] = args;
16891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16892 if (!SWIG_IsOK(res1)) {
16893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16894 }
16895 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16896 {
16897 PyThreadState* __tstate = wxPyBeginAllowThreads();
16898 {
16899 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16900 result = (wxString *) &_result_ref;
16901 }
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 {
16906 #if wxUSE_UNICODE
16907 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16908 #else
16909 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16910 #endif
16911 }
16912 return resultobj;
16913 fail:
16914 return NULL;
16915 }
16916
16917
16918 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16919 PyObject *resultobj = 0;
16920 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16921 int result;
16922 void *argp1 = 0 ;
16923 int res1 = 0 ;
16924 PyObject *swig_obj[1] ;
16925
16926 if (!args) SWIG_fail;
16927 swig_obj[0] = args;
16928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16929 if (!SWIG_IsOK(res1)) {
16930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16931 }
16932 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 resultobj = SWIG_From_int(static_cast< int >(result));
16940 return resultobj;
16941 fail:
16942 return NULL;
16943 }
16944
16945
16946 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16947 PyObject *obj;
16948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16949 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16950 return SWIG_Py_Void();
16951 }
16952
16953 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16954 return SWIG_Python_InitShadowInstance(args);
16955 }
16956
16957 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16958 PyObject *resultobj = 0;
16959 wxFileTypeInfo *arg1 = 0 ;
16960 wxFileType *result = 0 ;
16961 void *argp1 = 0 ;
16962 int res1 = 0 ;
16963 PyObject * obj0 = 0 ;
16964 char * kwnames[] = {
16965 (char *) "ftInfo", NULL
16966 };
16967
16968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16969 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16970 if (!SWIG_IsOK(res1)) {
16971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16972 }
16973 if (!argp1) {
16974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16975 }
16976 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16977 {
16978 PyThreadState* __tstate = wxPyBeginAllowThreads();
16979 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16991 PyObject *resultobj = 0;
16992 wxFileType *arg1 = (wxFileType *) 0 ;
16993 void *argp1 = 0 ;
16994 int res1 = 0 ;
16995 PyObject *swig_obj[1] ;
16996
16997 if (!args) SWIG_fail;
16998 swig_obj[0] = args;
16999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
17000 if (!SWIG_IsOK(res1)) {
17001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17002 }
17003 arg1 = reinterpret_cast< wxFileType * >(argp1);
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 delete arg1;
17007
17008 wxPyEndAllowThreads(__tstate);
17009 if (PyErr_Occurred()) SWIG_fail;
17010 }
17011 resultobj = SWIG_Py_Void();
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17019 PyObject *resultobj = 0;
17020 wxFileType *arg1 = (wxFileType *) 0 ;
17021 PyObject *result = 0 ;
17022 void *argp1 = 0 ;
17023 int res1 = 0 ;
17024 PyObject *swig_obj[1] ;
17025
17026 if (!args) SWIG_fail;
17027 swig_obj[0] = args;
17028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17029 if (!SWIG_IsOK(res1)) {
17030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17031 }
17032 arg1 = reinterpret_cast< wxFileType * >(argp1);
17033 {
17034 PyThreadState* __tstate = wxPyBeginAllowThreads();
17035 result = (PyObject *)wxFileType_GetMimeType(arg1);
17036 wxPyEndAllowThreads(__tstate);
17037 if (PyErr_Occurred()) SWIG_fail;
17038 }
17039 resultobj = result;
17040 return resultobj;
17041 fail:
17042 return NULL;
17043 }
17044
17045
17046 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17047 PyObject *resultobj = 0;
17048 wxFileType *arg1 = (wxFileType *) 0 ;
17049 PyObject *result = 0 ;
17050 void *argp1 = 0 ;
17051 int res1 = 0 ;
17052 PyObject *swig_obj[1] ;
17053
17054 if (!args) SWIG_fail;
17055 swig_obj[0] = args;
17056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17057 if (!SWIG_IsOK(res1)) {
17058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17059 }
17060 arg1 = reinterpret_cast< wxFileType * >(argp1);
17061 {
17062 PyThreadState* __tstate = wxPyBeginAllowThreads();
17063 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17064 wxPyEndAllowThreads(__tstate);
17065 if (PyErr_Occurred()) SWIG_fail;
17066 }
17067 resultobj = result;
17068 return resultobj;
17069 fail:
17070 return NULL;
17071 }
17072
17073
17074 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17075 PyObject *resultobj = 0;
17076 wxFileType *arg1 = (wxFileType *) 0 ;
17077 PyObject *result = 0 ;
17078 void *argp1 = 0 ;
17079 int res1 = 0 ;
17080 PyObject *swig_obj[1] ;
17081
17082 if (!args) SWIG_fail;
17083 swig_obj[0] = args;
17084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17085 if (!SWIG_IsOK(res1)) {
17086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17087 }
17088 arg1 = reinterpret_cast< wxFileType * >(argp1);
17089 {
17090 PyThreadState* __tstate = wxPyBeginAllowThreads();
17091 result = (PyObject *)wxFileType_GetExtensions(arg1);
17092 wxPyEndAllowThreads(__tstate);
17093 if (PyErr_Occurred()) SWIG_fail;
17094 }
17095 resultobj = result;
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17103 PyObject *resultobj = 0;
17104 wxFileType *arg1 = (wxFileType *) 0 ;
17105 wxIcon *result = 0 ;
17106 void *argp1 = 0 ;
17107 int res1 = 0 ;
17108 PyObject *swig_obj[1] ;
17109
17110 if (!args) SWIG_fail;
17111 swig_obj[0] = args;
17112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17113 if (!SWIG_IsOK(res1)) {
17114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17115 }
17116 arg1 = reinterpret_cast< wxFileType * >(argp1);
17117 {
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 result = (wxIcon *)wxFileType_GetIcon(arg1);
17120 wxPyEndAllowThreads(__tstate);
17121 if (PyErr_Occurred()) SWIG_fail;
17122 }
17123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17131 PyObject *resultobj = 0;
17132 wxFileType *arg1 = (wxFileType *) 0 ;
17133 PyObject *result = 0 ;
17134 void *argp1 = 0 ;
17135 int res1 = 0 ;
17136 PyObject *swig_obj[1] ;
17137
17138 if (!args) SWIG_fail;
17139 swig_obj[0] = args;
17140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17141 if (!SWIG_IsOK(res1)) {
17142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
17143 }
17144 arg1 = reinterpret_cast< wxFileType * >(argp1);
17145 {
17146 PyThreadState* __tstate = wxPyBeginAllowThreads();
17147 result = (PyObject *)wxFileType_GetIconInfo(arg1);
17148 wxPyEndAllowThreads(__tstate);
17149 if (PyErr_Occurred()) SWIG_fail;
17150 }
17151 resultobj = result;
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17159 PyObject *resultobj = 0;
17160 wxFileType *arg1 = (wxFileType *) 0 ;
17161 PyObject *result = 0 ;
17162 void *argp1 = 0 ;
17163 int res1 = 0 ;
17164 PyObject *swig_obj[1] ;
17165
17166 if (!args) SWIG_fail;
17167 swig_obj[0] = args;
17168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17169 if (!SWIG_IsOK(res1)) {
17170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17171 }
17172 arg1 = reinterpret_cast< wxFileType * >(argp1);
17173 {
17174 PyThreadState* __tstate = wxPyBeginAllowThreads();
17175 result = (PyObject *)wxFileType_GetDescription(arg1);
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 resultobj = result;
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj = 0;
17188 wxFileType *arg1 = (wxFileType *) 0 ;
17189 wxString *arg2 = 0 ;
17190 wxString const &arg3_defvalue = wxPyEmptyString ;
17191 wxString *arg3 = (wxString *) &arg3_defvalue ;
17192 PyObject *result = 0 ;
17193 void *argp1 = 0 ;
17194 int res1 = 0 ;
17195 bool temp2 = false ;
17196 bool temp3 = false ;
17197 PyObject * obj0 = 0 ;
17198 PyObject * obj1 = 0 ;
17199 PyObject * obj2 = 0 ;
17200 char * kwnames[] = {
17201 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17202 };
17203
17204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17206 if (!SWIG_IsOK(res1)) {
17207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17208 }
17209 arg1 = reinterpret_cast< wxFileType * >(argp1);
17210 {
17211 arg2 = wxString_in_helper(obj1);
17212 if (arg2 == NULL) SWIG_fail;
17213 temp2 = true;
17214 }
17215 if (obj2) {
17216 {
17217 arg3 = wxString_in_helper(obj2);
17218 if (arg3 == NULL) SWIG_fail;
17219 temp3 = true;
17220 }
17221 }
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 resultobj = result;
17229 {
17230 if (temp2)
17231 delete arg2;
17232 }
17233 {
17234 if (temp3)
17235 delete arg3;
17236 }
17237 return resultobj;
17238 fail:
17239 {
17240 if (temp2)
17241 delete arg2;
17242 }
17243 {
17244 if (temp3)
17245 delete arg3;
17246 }
17247 return NULL;
17248 }
17249
17250
17251 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17252 PyObject *resultobj = 0;
17253 wxFileType *arg1 = (wxFileType *) 0 ;
17254 wxString *arg2 = 0 ;
17255 wxString const &arg3_defvalue = wxPyEmptyString ;
17256 wxString *arg3 = (wxString *) &arg3_defvalue ;
17257 PyObject *result = 0 ;
17258 void *argp1 = 0 ;
17259 int res1 = 0 ;
17260 bool temp2 = false ;
17261 bool temp3 = false ;
17262 PyObject * obj0 = 0 ;
17263 PyObject * obj1 = 0 ;
17264 PyObject * obj2 = 0 ;
17265 char * kwnames[] = {
17266 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17267 };
17268
17269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17271 if (!SWIG_IsOK(res1)) {
17272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17273 }
17274 arg1 = reinterpret_cast< wxFileType * >(argp1);
17275 {
17276 arg2 = wxString_in_helper(obj1);
17277 if (arg2 == NULL) SWIG_fail;
17278 temp2 = true;
17279 }
17280 if (obj2) {
17281 {
17282 arg3 = wxString_in_helper(obj2);
17283 if (arg3 == NULL) SWIG_fail;
17284 temp3 = true;
17285 }
17286 }
17287 {
17288 PyThreadState* __tstate = wxPyBeginAllowThreads();
17289 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17290 wxPyEndAllowThreads(__tstate);
17291 if (PyErr_Occurred()) SWIG_fail;
17292 }
17293 resultobj = result;
17294 {
17295 if (temp2)
17296 delete arg2;
17297 }
17298 {
17299 if (temp3)
17300 delete arg3;
17301 }
17302 return resultobj;
17303 fail:
17304 {
17305 if (temp2)
17306 delete arg2;
17307 }
17308 {
17309 if (temp3)
17310 delete arg3;
17311 }
17312 return NULL;
17313 }
17314
17315
17316 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17317 PyObject *resultobj = 0;
17318 wxFileType *arg1 = (wxFileType *) 0 ;
17319 wxString *arg2 = 0 ;
17320 wxString const &arg3_defvalue = wxPyEmptyString ;
17321 wxString *arg3 = (wxString *) &arg3_defvalue ;
17322 PyObject *result = 0 ;
17323 void *argp1 = 0 ;
17324 int res1 = 0 ;
17325 bool temp2 = false ;
17326 bool temp3 = false ;
17327 PyObject * obj0 = 0 ;
17328 PyObject * obj1 = 0 ;
17329 PyObject * obj2 = 0 ;
17330 char * kwnames[] = {
17331 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17332 };
17333
17334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17336 if (!SWIG_IsOK(res1)) {
17337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17338 }
17339 arg1 = reinterpret_cast< wxFileType * >(argp1);
17340 {
17341 arg2 = wxString_in_helper(obj1);
17342 if (arg2 == NULL) SWIG_fail;
17343 temp2 = true;
17344 }
17345 if (obj2) {
17346 {
17347 arg3 = wxString_in_helper(obj2);
17348 if (arg3 == NULL) SWIG_fail;
17349 temp3 = true;
17350 }
17351 }
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 resultobj = result;
17359 {
17360 if (temp2)
17361 delete arg2;
17362 }
17363 {
17364 if (temp3)
17365 delete arg3;
17366 }
17367 return resultobj;
17368 fail:
17369 {
17370 if (temp2)
17371 delete arg2;
17372 }
17373 {
17374 if (temp3)
17375 delete arg3;
17376 }
17377 return NULL;
17378 }
17379
17380
17381 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17382 PyObject *resultobj = 0;
17383 wxFileType *arg1 = (wxFileType *) 0 ;
17384 wxString *arg2 = 0 ;
17385 wxString *arg3 = 0 ;
17386 bool arg4 = (bool) true ;
17387 bool result;
17388 void *argp1 = 0 ;
17389 int res1 = 0 ;
17390 bool temp2 = false ;
17391 bool temp3 = false ;
17392 bool val4 ;
17393 int ecode4 = 0 ;
17394 PyObject * obj0 = 0 ;
17395 PyObject * obj1 = 0 ;
17396 PyObject * obj2 = 0 ;
17397 PyObject * obj3 = 0 ;
17398 char * kwnames[] = {
17399 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17400 };
17401
17402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17404 if (!SWIG_IsOK(res1)) {
17405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17406 }
17407 arg1 = reinterpret_cast< wxFileType * >(argp1);
17408 {
17409 arg2 = wxString_in_helper(obj1);
17410 if (arg2 == NULL) SWIG_fail;
17411 temp2 = true;
17412 }
17413 {
17414 arg3 = wxString_in_helper(obj2);
17415 if (arg3 == NULL) SWIG_fail;
17416 temp3 = true;
17417 }
17418 if (obj3) {
17419 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17420 if (!SWIG_IsOK(ecode4)) {
17421 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17422 }
17423 arg4 = static_cast< bool >(val4);
17424 }
17425 {
17426 PyThreadState* __tstate = wxPyBeginAllowThreads();
17427 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 {
17432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17433 }
17434 {
17435 if (temp2)
17436 delete arg2;
17437 }
17438 {
17439 if (temp3)
17440 delete arg3;
17441 }
17442 return resultobj;
17443 fail:
17444 {
17445 if (temp2)
17446 delete arg2;
17447 }
17448 {
17449 if (temp3)
17450 delete arg3;
17451 }
17452 return NULL;
17453 }
17454
17455
17456 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17457 PyObject *resultobj = 0;
17458 wxFileType *arg1 = (wxFileType *) 0 ;
17459 wxString const &arg2_defvalue = wxPyEmptyString ;
17460 wxString *arg2 = (wxString *) &arg2_defvalue ;
17461 int arg3 = (int) 0 ;
17462 bool result;
17463 void *argp1 = 0 ;
17464 int res1 = 0 ;
17465 bool temp2 = false ;
17466 int val3 ;
17467 int ecode3 = 0 ;
17468 PyObject * obj0 = 0 ;
17469 PyObject * obj1 = 0 ;
17470 PyObject * obj2 = 0 ;
17471 char * kwnames[] = {
17472 (char *) "self",(char *) "cmd",(char *) "index", NULL
17473 };
17474
17475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17477 if (!SWIG_IsOK(res1)) {
17478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17479 }
17480 arg1 = reinterpret_cast< wxFileType * >(argp1);
17481 if (obj1) {
17482 {
17483 arg2 = wxString_in_helper(obj1);
17484 if (arg2 == NULL) SWIG_fail;
17485 temp2 = true;
17486 }
17487 }
17488 if (obj2) {
17489 ecode3 = SWIG_AsVal_int(obj2, &val3);
17490 if (!SWIG_IsOK(ecode3)) {
17491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17492 }
17493 arg3 = static_cast< int >(val3);
17494 }
17495 {
17496 PyThreadState* __tstate = wxPyBeginAllowThreads();
17497 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 {
17502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17503 }
17504 {
17505 if (temp2)
17506 delete arg2;
17507 }
17508 return resultobj;
17509 fail:
17510 {
17511 if (temp2)
17512 delete arg2;
17513 }
17514 return NULL;
17515 }
17516
17517
17518 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17519 PyObject *resultobj = 0;
17520 wxFileType *arg1 = (wxFileType *) 0 ;
17521 bool result;
17522 void *argp1 = 0 ;
17523 int res1 = 0 ;
17524 PyObject *swig_obj[1] ;
17525
17526 if (!args) SWIG_fail;
17527 swig_obj[0] = args;
17528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17529 if (!SWIG_IsOK(res1)) {
17530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17531 }
17532 arg1 = reinterpret_cast< wxFileType * >(argp1);
17533 {
17534 PyThreadState* __tstate = wxPyBeginAllowThreads();
17535 result = (bool)(arg1)->Unassociate();
17536 wxPyEndAllowThreads(__tstate);
17537 if (PyErr_Occurred()) SWIG_fail;
17538 }
17539 {
17540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17541 }
17542 return resultobj;
17543 fail:
17544 return NULL;
17545 }
17546
17547
17548 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17549 PyObject *resultobj = 0;
17550 wxString *arg1 = 0 ;
17551 wxString *arg2 = 0 ;
17552 wxString const &arg3_defvalue = wxPyEmptyString ;
17553 wxString *arg3 = (wxString *) &arg3_defvalue ;
17554 wxString result;
17555 bool temp1 = false ;
17556 bool temp2 = false ;
17557 bool temp3 = false ;
17558 PyObject * obj0 = 0 ;
17559 PyObject * obj1 = 0 ;
17560 PyObject * obj2 = 0 ;
17561 char * kwnames[] = {
17562 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17563 };
17564
17565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17566 {
17567 arg1 = wxString_in_helper(obj0);
17568 if (arg1 == NULL) SWIG_fail;
17569 temp1 = true;
17570 }
17571 {
17572 arg2 = wxString_in_helper(obj1);
17573 if (arg2 == NULL) SWIG_fail;
17574 temp2 = true;
17575 }
17576 if (obj2) {
17577 {
17578 arg3 = wxString_in_helper(obj2);
17579 if (arg3 == NULL) SWIG_fail;
17580 temp3 = true;
17581 }
17582 }
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17586 wxPyEndAllowThreads(__tstate);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 }
17589 {
17590 #if wxUSE_UNICODE
17591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17592 #else
17593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17594 #endif
17595 }
17596 {
17597 if (temp1)
17598 delete arg1;
17599 }
17600 {
17601 if (temp2)
17602 delete arg2;
17603 }
17604 {
17605 if (temp3)
17606 delete arg3;
17607 }
17608 return resultobj;
17609 fail:
17610 {
17611 if (temp1)
17612 delete arg1;
17613 }
17614 {
17615 if (temp2)
17616 delete arg2;
17617 }
17618 {
17619 if (temp3)
17620 delete arg3;
17621 }
17622 return NULL;
17623 }
17624
17625
17626 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17627 PyObject *obj;
17628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17629 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17630 return SWIG_Py_Void();
17631 }
17632
17633 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17634 return SWIG_Python_InitShadowInstance(args);
17635 }
17636
17637 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17638 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17639 return 1;
17640 }
17641
17642
17643 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17644 PyObject *pyobj = 0;
17645
17646 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17647 return pyobj;
17648 }
17649
17650
17651 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj = 0;
17653 wxString *arg1 = 0 ;
17654 wxString *arg2 = 0 ;
17655 bool result;
17656 bool temp1 = false ;
17657 bool temp2 = false ;
17658 PyObject * obj0 = 0 ;
17659 PyObject * obj1 = 0 ;
17660 char * kwnames[] = {
17661 (char *) "mimeType",(char *) "wildcard", NULL
17662 };
17663
17664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17665 {
17666 arg1 = wxString_in_helper(obj0);
17667 if (arg1 == NULL) SWIG_fail;
17668 temp1 = true;
17669 }
17670 {
17671 arg2 = wxString_in_helper(obj1);
17672 if (arg2 == NULL) SWIG_fail;
17673 temp2 = true;
17674 }
17675 {
17676 PyThreadState* __tstate = wxPyBeginAllowThreads();
17677 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 {
17682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17683 }
17684 {
17685 if (temp1)
17686 delete arg1;
17687 }
17688 {
17689 if (temp2)
17690 delete arg2;
17691 }
17692 return resultobj;
17693 fail:
17694 {
17695 if (temp1)
17696 delete arg1;
17697 }
17698 {
17699 if (temp2)
17700 delete arg2;
17701 }
17702 return NULL;
17703 }
17704
17705
17706 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17707 PyObject *resultobj = 0;
17708 wxMimeTypesManager *result = 0 ;
17709
17710 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17711 {
17712 PyThreadState* __tstate = wxPyBeginAllowThreads();
17713 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17714 wxPyEndAllowThreads(__tstate);
17715 if (PyErr_Occurred()) SWIG_fail;
17716 }
17717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17718 return resultobj;
17719 fail:
17720 return NULL;
17721 }
17722
17723
17724 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17725 PyObject *resultobj = 0;
17726 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17727 int arg2 = (int) wxMAILCAP_ALL ;
17728 wxString const &arg3_defvalue = wxPyEmptyString ;
17729 wxString *arg3 = (wxString *) &arg3_defvalue ;
17730 void *argp1 = 0 ;
17731 int res1 = 0 ;
17732 int val2 ;
17733 int ecode2 = 0 ;
17734 bool temp3 = false ;
17735 PyObject * obj0 = 0 ;
17736 PyObject * obj1 = 0 ;
17737 PyObject * obj2 = 0 ;
17738 char * kwnames[] = {
17739 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17740 };
17741
17742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17744 if (!SWIG_IsOK(res1)) {
17745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17746 }
17747 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17748 if (obj1) {
17749 ecode2 = SWIG_AsVal_int(obj1, &val2);
17750 if (!SWIG_IsOK(ecode2)) {
17751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17752 }
17753 arg2 = static_cast< int >(val2);
17754 }
17755 if (obj2) {
17756 {
17757 arg3 = wxString_in_helper(obj2);
17758 if (arg3 == NULL) SWIG_fail;
17759 temp3 = true;
17760 }
17761 }
17762 {
17763 PyThreadState* __tstate = wxPyBeginAllowThreads();
17764 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17765 wxPyEndAllowThreads(__tstate);
17766 if (PyErr_Occurred()) SWIG_fail;
17767 }
17768 resultobj = SWIG_Py_Void();
17769 {
17770 if (temp3)
17771 delete arg3;
17772 }
17773 return resultobj;
17774 fail:
17775 {
17776 if (temp3)
17777 delete arg3;
17778 }
17779 return NULL;
17780 }
17781
17782
17783 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17784 PyObject *resultobj = 0;
17785 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17786 void *argp1 = 0 ;
17787 int res1 = 0 ;
17788 PyObject *swig_obj[1] ;
17789
17790 if (!args) SWIG_fail;
17791 swig_obj[0] = args;
17792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17793 if (!SWIG_IsOK(res1)) {
17794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17795 }
17796 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17797 {
17798 PyThreadState* __tstate = wxPyBeginAllowThreads();
17799 (arg1)->ClearData();
17800 wxPyEndAllowThreads(__tstate);
17801 if (PyErr_Occurred()) SWIG_fail;
17802 }
17803 resultobj = SWIG_Py_Void();
17804 return resultobj;
17805 fail:
17806 return NULL;
17807 }
17808
17809
17810 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17811 PyObject *resultobj = 0;
17812 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17813 wxString *arg2 = 0 ;
17814 wxFileType *result = 0 ;
17815 void *argp1 = 0 ;
17816 int res1 = 0 ;
17817 bool temp2 = false ;
17818 PyObject * obj0 = 0 ;
17819 PyObject * obj1 = 0 ;
17820 char * kwnames[] = {
17821 (char *) "self",(char *) "ext", NULL
17822 };
17823
17824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17826 if (!SWIG_IsOK(res1)) {
17827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17828 }
17829 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17830 {
17831 arg2 = wxString_in_helper(obj1);
17832 if (arg2 == NULL) SWIG_fail;
17833 temp2 = true;
17834 }
17835 {
17836 PyThreadState* __tstate = wxPyBeginAllowThreads();
17837 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17838 wxPyEndAllowThreads(__tstate);
17839 if (PyErr_Occurred()) SWIG_fail;
17840 }
17841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17842 {
17843 if (temp2)
17844 delete arg2;
17845 }
17846 return resultobj;
17847 fail:
17848 {
17849 if (temp2)
17850 delete arg2;
17851 }
17852 return NULL;
17853 }
17854
17855
17856 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17857 PyObject *resultobj = 0;
17858 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17859 wxString *arg2 = 0 ;
17860 wxFileType *result = 0 ;
17861 void *argp1 = 0 ;
17862 int res1 = 0 ;
17863 bool temp2 = false ;
17864 PyObject * obj0 = 0 ;
17865 PyObject * obj1 = 0 ;
17866 char * kwnames[] = {
17867 (char *) "self",(char *) "mimeType", NULL
17868 };
17869
17870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17872 if (!SWIG_IsOK(res1)) {
17873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17874 }
17875 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17876 {
17877 arg2 = wxString_in_helper(obj1);
17878 if (arg2 == NULL) SWIG_fail;
17879 temp2 = true;
17880 }
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17884 wxPyEndAllowThreads(__tstate);
17885 if (PyErr_Occurred()) SWIG_fail;
17886 }
17887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17888 {
17889 if (temp2)
17890 delete arg2;
17891 }
17892 return resultobj;
17893 fail:
17894 {
17895 if (temp2)
17896 delete arg2;
17897 }
17898 return NULL;
17899 }
17900
17901
17902 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17903 PyObject *resultobj = 0;
17904 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17905 wxString *arg2 = 0 ;
17906 bool arg3 = (bool) false ;
17907 bool result;
17908 void *argp1 = 0 ;
17909 int res1 = 0 ;
17910 bool temp2 = false ;
17911 bool val3 ;
17912 int ecode3 = 0 ;
17913 PyObject * obj0 = 0 ;
17914 PyObject * obj1 = 0 ;
17915 PyObject * obj2 = 0 ;
17916 char * kwnames[] = {
17917 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17918 };
17919
17920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17922 if (!SWIG_IsOK(res1)) {
17923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17924 }
17925 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17926 {
17927 arg2 = wxString_in_helper(obj1);
17928 if (arg2 == NULL) SWIG_fail;
17929 temp2 = true;
17930 }
17931 if (obj2) {
17932 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17933 if (!SWIG_IsOK(ecode3)) {
17934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17935 }
17936 arg3 = static_cast< bool >(val3);
17937 }
17938 {
17939 PyThreadState* __tstate = wxPyBeginAllowThreads();
17940 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17941 wxPyEndAllowThreads(__tstate);
17942 if (PyErr_Occurred()) SWIG_fail;
17943 }
17944 {
17945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17946 }
17947 {
17948 if (temp2)
17949 delete arg2;
17950 }
17951 return resultobj;
17952 fail:
17953 {
17954 if (temp2)
17955 delete arg2;
17956 }
17957 return NULL;
17958 }
17959
17960
17961 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj = 0;
17963 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17964 wxString *arg2 = 0 ;
17965 bool result;
17966 void *argp1 = 0 ;
17967 int res1 = 0 ;
17968 bool temp2 = false ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char * kwnames[] = {
17972 (char *) "self",(char *) "filename", NULL
17973 };
17974
17975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17979 }
17980 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17981 {
17982 arg2 = wxString_in_helper(obj1);
17983 if (arg2 == NULL) SWIG_fail;
17984 temp2 = true;
17985 }
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17989 wxPyEndAllowThreads(__tstate);
17990 if (PyErr_Occurred()) SWIG_fail;
17991 }
17992 {
17993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17994 }
17995 {
17996 if (temp2)
17997 delete arg2;
17998 }
17999 return resultobj;
18000 fail:
18001 {
18002 if (temp2)
18003 delete arg2;
18004 }
18005 return NULL;
18006 }
18007
18008
18009 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18010 PyObject *resultobj = 0;
18011 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18012 PyObject *result = 0 ;
18013 void *argp1 = 0 ;
18014 int res1 = 0 ;
18015 PyObject *swig_obj[1] ;
18016
18017 if (!args) SWIG_fail;
18018 swig_obj[0] = args;
18019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18020 if (!SWIG_IsOK(res1)) {
18021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18022 }
18023 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18024 {
18025 PyThreadState* __tstate = wxPyBeginAllowThreads();
18026 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 resultobj = result;
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18038 PyObject *resultobj = 0;
18039 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18040 wxFileTypeInfo *arg2 = 0 ;
18041 void *argp1 = 0 ;
18042 int res1 = 0 ;
18043 void *argp2 = 0 ;
18044 int res2 = 0 ;
18045 PyObject * obj0 = 0 ;
18046 PyObject * obj1 = 0 ;
18047 char * kwnames[] = {
18048 (char *) "self",(char *) "ft", NULL
18049 };
18050
18051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18053 if (!SWIG_IsOK(res1)) {
18054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18055 }
18056 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18057 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18058 if (!SWIG_IsOK(res2)) {
18059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18060 }
18061 if (!argp2) {
18062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18063 }
18064 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18065 {
18066 PyThreadState* __tstate = wxPyBeginAllowThreads();
18067 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18068 wxPyEndAllowThreads(__tstate);
18069 if (PyErr_Occurred()) SWIG_fail;
18070 }
18071 resultobj = SWIG_Py_Void();
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18079 PyObject *resultobj = 0;
18080 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18081 wxFileTypeInfo *arg2 = 0 ;
18082 wxFileType *result = 0 ;
18083 void *argp1 = 0 ;
18084 int res1 = 0 ;
18085 void *argp2 = 0 ;
18086 int res2 = 0 ;
18087 PyObject * obj0 = 0 ;
18088 PyObject * obj1 = 0 ;
18089 char * kwnames[] = {
18090 (char *) "self",(char *) "ftInfo", NULL
18091 };
18092
18093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18095 if (!SWIG_IsOK(res1)) {
18096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18097 }
18098 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18099 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18100 if (!SWIG_IsOK(res2)) {
18101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18102 }
18103 if (!argp2) {
18104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18105 }
18106 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18107 {
18108 PyThreadState* __tstate = wxPyBeginAllowThreads();
18109 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
18110 wxPyEndAllowThreads(__tstate);
18111 if (PyErr_Occurred()) SWIG_fail;
18112 }
18113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18114 return resultobj;
18115 fail:
18116 return NULL;
18117 }
18118
18119
18120 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18121 PyObject *resultobj = 0;
18122 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18123 wxFileType *arg2 = (wxFileType *) 0 ;
18124 bool result;
18125 void *argp1 = 0 ;
18126 int res1 = 0 ;
18127 void *argp2 = 0 ;
18128 int res2 = 0 ;
18129 PyObject * obj0 = 0 ;
18130 PyObject * obj1 = 0 ;
18131 char * kwnames[] = {
18132 (char *) "self",(char *) "ft", NULL
18133 };
18134
18135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
18136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18137 if (!SWIG_IsOK(res1)) {
18138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18139 }
18140 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18141 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
18142 if (!SWIG_IsOK(res2)) {
18143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
18144 }
18145 arg2 = reinterpret_cast< wxFileType * >(argp2);
18146 {
18147 PyThreadState* __tstate = wxPyBeginAllowThreads();
18148 result = (bool)(arg1)->Unassociate(arg2);
18149 wxPyEndAllowThreads(__tstate);
18150 if (PyErr_Occurred()) SWIG_fail;
18151 }
18152 {
18153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18154 }
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18162 PyObject *resultobj = 0;
18163 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18164 void *argp1 = 0 ;
18165 int res1 = 0 ;
18166 PyObject *swig_obj[1] ;
18167
18168 if (!args) SWIG_fail;
18169 swig_obj[0] = args;
18170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18171 if (!SWIG_IsOK(res1)) {
18172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18173 }
18174 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18175 {
18176 PyThreadState* __tstate = wxPyBeginAllowThreads();
18177 delete arg1;
18178
18179 wxPyEndAllowThreads(__tstate);
18180 if (PyErr_Occurred()) SWIG_fail;
18181 }
18182 resultobj = SWIG_Py_Void();
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18190 PyObject *obj;
18191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18192 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18193 return SWIG_Py_Void();
18194 }
18195
18196 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18197 return SWIG_Python_InitShadowInstance(args);
18198 }
18199
18200 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18201 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18202 return 1;
18203 }
18204
18205
18206 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18207 PyObject *pyobj = 0;
18208
18209 {
18210 #if wxUSE_UNICODE
18211 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18212 #else
18213 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18214 #endif
18215 }
18216 return pyobj;
18217 }
18218
18219
18220 SWIGINTERN int ART_MENU_set(PyObject *) {
18221 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18222 return 1;
18223 }
18224
18225
18226 SWIGINTERN PyObject *ART_MENU_get(void) {
18227 PyObject *pyobj = 0;
18228
18229 {
18230 #if wxUSE_UNICODE
18231 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18232 #else
18233 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18234 #endif
18235 }
18236 return pyobj;
18237 }
18238
18239
18240 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18241 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18242 return 1;
18243 }
18244
18245
18246 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18247 PyObject *pyobj = 0;
18248
18249 {
18250 #if wxUSE_UNICODE
18251 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18252 #else
18253 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18254 #endif
18255 }
18256 return pyobj;
18257 }
18258
18259
18260 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18261 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18262 return 1;
18263 }
18264
18265
18266 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18267 PyObject *pyobj = 0;
18268
18269 {
18270 #if wxUSE_UNICODE
18271 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18272 #else
18273 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18274 #endif
18275 }
18276 return pyobj;
18277 }
18278
18279
18280 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18281 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18282 return 1;
18283 }
18284
18285
18286 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18287 PyObject *pyobj = 0;
18288
18289 {
18290 #if wxUSE_UNICODE
18291 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18292 #else
18293 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18294 #endif
18295 }
18296 return pyobj;
18297 }
18298
18299
18300 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18301 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18302 return 1;
18303 }
18304
18305
18306 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18307 PyObject *pyobj = 0;
18308
18309 {
18310 #if wxUSE_UNICODE
18311 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18312 #else
18313 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18314 #endif
18315 }
18316 return pyobj;
18317 }
18318
18319
18320 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18321 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18322 return 1;
18323 }
18324
18325
18326 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18327 PyObject *pyobj = 0;
18328
18329 {
18330 #if wxUSE_UNICODE
18331 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18332 #else
18333 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18334 #endif
18335 }
18336 return pyobj;
18337 }
18338
18339
18340 SWIGINTERN int ART_OTHER_set(PyObject *) {
18341 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18342 return 1;
18343 }
18344
18345
18346 SWIGINTERN PyObject *ART_OTHER_get(void) {
18347 PyObject *pyobj = 0;
18348
18349 {
18350 #if wxUSE_UNICODE
18351 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18352 #else
18353 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18354 #endif
18355 }
18356 return pyobj;
18357 }
18358
18359
18360 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18361 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18362 return 1;
18363 }
18364
18365
18366 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18367 PyObject *pyobj = 0;
18368
18369 {
18370 #if wxUSE_UNICODE
18371 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18372 #else
18373 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18374 #endif
18375 }
18376 return pyobj;
18377 }
18378
18379
18380 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18381 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18382 return 1;
18383 }
18384
18385
18386 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18387 PyObject *pyobj = 0;
18388
18389 {
18390 #if wxUSE_UNICODE
18391 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18392 #else
18393 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18394 #endif
18395 }
18396 return pyobj;
18397 }
18398
18399
18400 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18401 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18402 return 1;
18403 }
18404
18405
18406 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18407 PyObject *pyobj = 0;
18408
18409 {
18410 #if wxUSE_UNICODE
18411 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18412 #else
18413 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18414 #endif
18415 }
18416 return pyobj;
18417 }
18418
18419
18420 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18421 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18422 return 1;
18423 }
18424
18425
18426 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18427 PyObject *pyobj = 0;
18428
18429 {
18430 #if wxUSE_UNICODE
18431 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18432 #else
18433 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18434 #endif
18435 }
18436 return pyobj;
18437 }
18438
18439
18440 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18441 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18442 return 1;
18443 }
18444
18445
18446 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18447 PyObject *pyobj = 0;
18448
18449 {
18450 #if wxUSE_UNICODE
18451 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18452 #else
18453 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18454 #endif
18455 }
18456 return pyobj;
18457 }
18458
18459
18460 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18461 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18462 return 1;
18463 }
18464
18465
18466 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18467 PyObject *pyobj = 0;
18468
18469 {
18470 #if wxUSE_UNICODE
18471 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18472 #else
18473 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18474 #endif
18475 }
18476 return pyobj;
18477 }
18478
18479
18480 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18481 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18482 return 1;
18483 }
18484
18485
18486 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18487 PyObject *pyobj = 0;
18488
18489 {
18490 #if wxUSE_UNICODE
18491 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18492 #else
18493 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18494 #endif
18495 }
18496 return pyobj;
18497 }
18498
18499
18500 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18501 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18502 return 1;
18503 }
18504
18505
18506 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18507 PyObject *pyobj = 0;
18508
18509 {
18510 #if wxUSE_UNICODE
18511 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18512 #else
18513 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18514 #endif
18515 }
18516 return pyobj;
18517 }
18518
18519
18520 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18521 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18522 return 1;
18523 }
18524
18525
18526 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18527 PyObject *pyobj = 0;
18528
18529 {
18530 #if wxUSE_UNICODE
18531 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18532 #else
18533 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18534 #endif
18535 }
18536 return pyobj;
18537 }
18538
18539
18540 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18541 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18542 return 1;
18543 }
18544
18545
18546 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18547 PyObject *pyobj = 0;
18548
18549 {
18550 #if wxUSE_UNICODE
18551 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18552 #else
18553 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18554 #endif
18555 }
18556 return pyobj;
18557 }
18558
18559
18560 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18561 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18562 return 1;
18563 }
18564
18565
18566 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18567 PyObject *pyobj = 0;
18568
18569 {
18570 #if wxUSE_UNICODE
18571 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18572 #else
18573 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18574 #endif
18575 }
18576 return pyobj;
18577 }
18578
18579
18580 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18581 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18582 return 1;
18583 }
18584
18585
18586 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18587 PyObject *pyobj = 0;
18588
18589 {
18590 #if wxUSE_UNICODE
18591 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18592 #else
18593 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18594 #endif
18595 }
18596 return pyobj;
18597 }
18598
18599
18600 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18601 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18602 return 1;
18603 }
18604
18605
18606 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18607 PyObject *pyobj = 0;
18608
18609 {
18610 #if wxUSE_UNICODE
18611 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18612 #else
18613 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18614 #endif
18615 }
18616 return pyobj;
18617 }
18618
18619
18620 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18621 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18622 return 1;
18623 }
18624
18625
18626 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18627 PyObject *pyobj = 0;
18628
18629 {
18630 #if wxUSE_UNICODE
18631 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18632 #else
18633 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18634 #endif
18635 }
18636 return pyobj;
18637 }
18638
18639
18640 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18641 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18642 return 1;
18643 }
18644
18645
18646 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18647 PyObject *pyobj = 0;
18648
18649 {
18650 #if wxUSE_UNICODE
18651 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18652 #else
18653 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18654 #endif
18655 }
18656 return pyobj;
18657 }
18658
18659
18660 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18661 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18662 return 1;
18663 }
18664
18665
18666 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18667 PyObject *pyobj = 0;
18668
18669 {
18670 #if wxUSE_UNICODE
18671 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18672 #else
18673 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18674 #endif
18675 }
18676 return pyobj;
18677 }
18678
18679
18680 SWIGINTERN int ART_PRINT_set(PyObject *) {
18681 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18682 return 1;
18683 }
18684
18685
18686 SWIGINTERN PyObject *ART_PRINT_get(void) {
18687 PyObject *pyobj = 0;
18688
18689 {
18690 #if wxUSE_UNICODE
18691 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18692 #else
18693 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18694 #endif
18695 }
18696 return pyobj;
18697 }
18698
18699
18700 SWIGINTERN int ART_HELP_set(PyObject *) {
18701 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18702 return 1;
18703 }
18704
18705
18706 SWIGINTERN PyObject *ART_HELP_get(void) {
18707 PyObject *pyobj = 0;
18708
18709 {
18710 #if wxUSE_UNICODE
18711 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18712 #else
18713 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18714 #endif
18715 }
18716 return pyobj;
18717 }
18718
18719
18720 SWIGINTERN int ART_TIP_set(PyObject *) {
18721 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18722 return 1;
18723 }
18724
18725
18726 SWIGINTERN PyObject *ART_TIP_get(void) {
18727 PyObject *pyobj = 0;
18728
18729 {
18730 #if wxUSE_UNICODE
18731 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18732 #else
18733 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18734 #endif
18735 }
18736 return pyobj;
18737 }
18738
18739
18740 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18741 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18742 return 1;
18743 }
18744
18745
18746 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18747 PyObject *pyobj = 0;
18748
18749 {
18750 #if wxUSE_UNICODE
18751 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18752 #else
18753 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18754 #endif
18755 }
18756 return pyobj;
18757 }
18758
18759
18760 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18761 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18762 return 1;
18763 }
18764
18765
18766 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18767 PyObject *pyobj = 0;
18768
18769 {
18770 #if wxUSE_UNICODE
18771 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18772 #else
18773 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18774 #endif
18775 }
18776 return pyobj;
18777 }
18778
18779
18780 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18781 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18782 return 1;
18783 }
18784
18785
18786 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18787 PyObject *pyobj = 0;
18788
18789 {
18790 #if wxUSE_UNICODE
18791 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18792 #else
18793 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18794 #endif
18795 }
18796 return pyobj;
18797 }
18798
18799
18800 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18801 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18802 return 1;
18803 }
18804
18805
18806 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18807 PyObject *pyobj = 0;
18808
18809 {
18810 #if wxUSE_UNICODE
18811 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18812 #else
18813 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18814 #endif
18815 }
18816 return pyobj;
18817 }
18818
18819
18820 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18821 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18822 return 1;
18823 }
18824
18825
18826 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18827 PyObject *pyobj = 0;
18828
18829 {
18830 #if wxUSE_UNICODE
18831 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18832 #else
18833 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18834 #endif
18835 }
18836 return pyobj;
18837 }
18838
18839
18840 SWIGINTERN int ART_CDROM_set(PyObject *) {
18841 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18842 return 1;
18843 }
18844
18845
18846 SWIGINTERN PyObject *ART_CDROM_get(void) {
18847 PyObject *pyobj = 0;
18848
18849 {
18850 #if wxUSE_UNICODE
18851 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18852 #else
18853 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18854 #endif
18855 }
18856 return pyobj;
18857 }
18858
18859
18860 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18861 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18862 return 1;
18863 }
18864
18865
18866 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18867 PyObject *pyobj = 0;
18868
18869 {
18870 #if wxUSE_UNICODE
18871 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18872 #else
18873 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18874 #endif
18875 }
18876 return pyobj;
18877 }
18878
18879
18880 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18881 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18882 return 1;
18883 }
18884
18885
18886 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18887 PyObject *pyobj = 0;
18888
18889 {
18890 #if wxUSE_UNICODE
18891 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18892 #else
18893 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18894 #endif
18895 }
18896 return pyobj;
18897 }
18898
18899
18900 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18901 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18902 return 1;
18903 }
18904
18905
18906 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18907 PyObject *pyobj = 0;
18908
18909 {
18910 #if wxUSE_UNICODE
18911 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18912 #else
18913 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18914 #endif
18915 }
18916 return pyobj;
18917 }
18918
18919
18920 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18921 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18922 return 1;
18923 }
18924
18925
18926 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18927 PyObject *pyobj = 0;
18928
18929 {
18930 #if wxUSE_UNICODE
18931 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18932 #else
18933 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18934 #endif
18935 }
18936 return pyobj;
18937 }
18938
18939
18940 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18941 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18942 return 1;
18943 }
18944
18945
18946 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18947 PyObject *pyobj = 0;
18948
18949 {
18950 #if wxUSE_UNICODE
18951 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18952 #else
18953 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18954 #endif
18955 }
18956 return pyobj;
18957 }
18958
18959
18960 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18961 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18962 return 1;
18963 }
18964
18965
18966 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18967 PyObject *pyobj = 0;
18968
18969 {
18970 #if wxUSE_UNICODE
18971 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18972 #else
18973 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18974 #endif
18975 }
18976 return pyobj;
18977 }
18978
18979
18980 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18981 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18982 return 1;
18983 }
18984
18985
18986 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18987 PyObject *pyobj = 0;
18988
18989 {
18990 #if wxUSE_UNICODE
18991 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18992 #else
18993 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18994 #endif
18995 }
18996 return pyobj;
18997 }
18998
18999
19000 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19001 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19002 return 1;
19003 }
19004
19005
19006 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19007 PyObject *pyobj = 0;
19008
19009 {
19010 #if wxUSE_UNICODE
19011 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19012 #else
19013 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19014 #endif
19015 }
19016 return pyobj;
19017 }
19018
19019
19020 SWIGINTERN int ART_ERROR_set(PyObject *) {
19021 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19022 return 1;
19023 }
19024
19025
19026 SWIGINTERN PyObject *ART_ERROR_get(void) {
19027 PyObject *pyobj = 0;
19028
19029 {
19030 #if wxUSE_UNICODE
19031 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19032 #else
19033 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19034 #endif
19035 }
19036 return pyobj;
19037 }
19038
19039
19040 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19041 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19042 return 1;
19043 }
19044
19045
19046 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19047 PyObject *pyobj = 0;
19048
19049 {
19050 #if wxUSE_UNICODE
19051 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19052 #else
19053 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19054 #endif
19055 }
19056 return pyobj;
19057 }
19058
19059
19060 SWIGINTERN int ART_WARNING_set(PyObject *) {
19061 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19062 return 1;
19063 }
19064
19065
19066 SWIGINTERN PyObject *ART_WARNING_get(void) {
19067 PyObject *pyobj = 0;
19068
19069 {
19070 #if wxUSE_UNICODE
19071 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19072 #else
19073 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19074 #endif
19075 }
19076 return pyobj;
19077 }
19078
19079
19080 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19081 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19082 return 1;
19083 }
19084
19085
19086 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19087 PyObject *pyobj = 0;
19088
19089 {
19090 #if wxUSE_UNICODE
19091 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19092 #else
19093 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19094 #endif
19095 }
19096 return pyobj;
19097 }
19098
19099
19100 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19101 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19102 return 1;
19103 }
19104
19105
19106 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19107 PyObject *pyobj = 0;
19108
19109 {
19110 #if wxUSE_UNICODE
19111 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19112 #else
19113 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19114 #endif
19115 }
19116 return pyobj;
19117 }
19118
19119
19120 SWIGINTERN int ART_COPY_set(PyObject *) {
19121 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
19122 return 1;
19123 }
19124
19125
19126 SWIGINTERN PyObject *ART_COPY_get(void) {
19127 PyObject *pyobj = 0;
19128
19129 {
19130 #if wxUSE_UNICODE
19131 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19132 #else
19133 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19134 #endif
19135 }
19136 return pyobj;
19137 }
19138
19139
19140 SWIGINTERN int ART_CUT_set(PyObject *) {
19141 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
19142 return 1;
19143 }
19144
19145
19146 SWIGINTERN PyObject *ART_CUT_get(void) {
19147 PyObject *pyobj = 0;
19148
19149 {
19150 #if wxUSE_UNICODE
19151 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19152 #else
19153 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19154 #endif
19155 }
19156 return pyobj;
19157 }
19158
19159
19160 SWIGINTERN int ART_PASTE_set(PyObject *) {
19161 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
19162 return 1;
19163 }
19164
19165
19166 SWIGINTERN PyObject *ART_PASTE_get(void) {
19167 PyObject *pyobj = 0;
19168
19169 {
19170 #if wxUSE_UNICODE
19171 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19172 #else
19173 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19174 #endif
19175 }
19176 return pyobj;
19177 }
19178
19179
19180 SWIGINTERN int ART_DELETE_set(PyObject *) {
19181 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19182 return 1;
19183 }
19184
19185
19186 SWIGINTERN PyObject *ART_DELETE_get(void) {
19187 PyObject *pyobj = 0;
19188
19189 {
19190 #if wxUSE_UNICODE
19191 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19192 #else
19193 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19194 #endif
19195 }
19196 return pyobj;
19197 }
19198
19199
19200 SWIGINTERN int ART_NEW_set(PyObject *) {
19201 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19202 return 1;
19203 }
19204
19205
19206 SWIGINTERN PyObject *ART_NEW_get(void) {
19207 PyObject *pyobj = 0;
19208
19209 {
19210 #if wxUSE_UNICODE
19211 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19212 #else
19213 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19214 #endif
19215 }
19216 return pyobj;
19217 }
19218
19219
19220 SWIGINTERN int ART_UNDO_set(PyObject *) {
19221 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19222 return 1;
19223 }
19224
19225
19226 SWIGINTERN PyObject *ART_UNDO_get(void) {
19227 PyObject *pyobj = 0;
19228
19229 {
19230 #if wxUSE_UNICODE
19231 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19232 #else
19233 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19234 #endif
19235 }
19236 return pyobj;
19237 }
19238
19239
19240 SWIGINTERN int ART_REDO_set(PyObject *) {
19241 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19242 return 1;
19243 }
19244
19245
19246 SWIGINTERN PyObject *ART_REDO_get(void) {
19247 PyObject *pyobj = 0;
19248
19249 {
19250 #if wxUSE_UNICODE
19251 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19252 #else
19253 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19254 #endif
19255 }
19256 return pyobj;
19257 }
19258
19259
19260 SWIGINTERN int ART_QUIT_set(PyObject *) {
19261 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19262 return 1;
19263 }
19264
19265
19266 SWIGINTERN PyObject *ART_QUIT_get(void) {
19267 PyObject *pyobj = 0;
19268
19269 {
19270 #if wxUSE_UNICODE
19271 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19272 #else
19273 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19274 #endif
19275 }
19276 return pyobj;
19277 }
19278
19279
19280 SWIGINTERN int ART_FIND_set(PyObject *) {
19281 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19282 return 1;
19283 }
19284
19285
19286 SWIGINTERN PyObject *ART_FIND_get(void) {
19287 PyObject *pyobj = 0;
19288
19289 {
19290 #if wxUSE_UNICODE
19291 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19292 #else
19293 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19294 #endif
19295 }
19296 return pyobj;
19297 }
19298
19299
19300 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19301 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19302 return 1;
19303 }
19304
19305
19306 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19307 PyObject *pyobj = 0;
19308
19309 {
19310 #if wxUSE_UNICODE
19311 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19312 #else
19313 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19314 #endif
19315 }
19316 return pyobj;
19317 }
19318
19319
19320 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19321 PyObject *resultobj = 0;
19322 wxPyArtProvider *result = 0 ;
19323
19324 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19325 {
19326 if (!wxPyCheckForApp()) SWIG_fail;
19327 PyThreadState* __tstate = wxPyBeginAllowThreads();
19328 result = (wxPyArtProvider *)new wxPyArtProvider();
19329 wxPyEndAllowThreads(__tstate);
19330 if (PyErr_Occurred()) SWIG_fail;
19331 }
19332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19333 return resultobj;
19334 fail:
19335 return NULL;
19336 }
19337
19338
19339 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19340 PyObject *resultobj = 0;
19341 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19342 void *argp1 = 0 ;
19343 int res1 = 0 ;
19344 PyObject *swig_obj[1] ;
19345
19346 if (!args) SWIG_fail;
19347 swig_obj[0] = args;
19348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19349 if (!SWIG_IsOK(res1)) {
19350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19351 }
19352 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19353 {
19354 PyThreadState* __tstate = wxPyBeginAllowThreads();
19355 delete arg1;
19356
19357 wxPyEndAllowThreads(__tstate);
19358 if (PyErr_Occurred()) SWIG_fail;
19359 }
19360 resultobj = SWIG_Py_Void();
19361 return resultobj;
19362 fail:
19363 return NULL;
19364 }
19365
19366
19367 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19368 PyObject *resultobj = 0;
19369 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19370 PyObject *arg2 = (PyObject *) 0 ;
19371 PyObject *arg3 = (PyObject *) 0 ;
19372 void *argp1 = 0 ;
19373 int res1 = 0 ;
19374 PyObject * obj0 = 0 ;
19375 PyObject * obj1 = 0 ;
19376 PyObject * obj2 = 0 ;
19377 char * kwnames[] = {
19378 (char *) "self",(char *) "self",(char *) "_class", NULL
19379 };
19380
19381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19383 if (!SWIG_IsOK(res1)) {
19384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19385 }
19386 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19387 arg2 = obj1;
19388 arg3 = obj2;
19389 {
19390 PyThreadState* __tstate = wxPyBeginAllowThreads();
19391 (arg1)->_setCallbackInfo(arg2,arg3);
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 resultobj = SWIG_Py_Void();
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19403 PyObject *resultobj = 0;
19404 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19405 int res1 = 0 ;
19406 PyObject * obj0 = 0 ;
19407 char * kwnames[] = {
19408 (char *) "provider", NULL
19409 };
19410
19411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19412 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19413 if (!SWIG_IsOK(res1)) {
19414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19415 }
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 wxPyArtProvider::PushProvider(arg1);
19419 wxPyEndAllowThreads(__tstate);
19420 if (PyErr_Occurred()) SWIG_fail;
19421 }
19422 resultobj = SWIG_Py_Void();
19423 return resultobj;
19424 fail:
19425 return NULL;
19426 }
19427
19428
19429 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19430 PyObject *resultobj = 0;
19431 bool result;
19432
19433 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 result = (bool)wxPyArtProvider::PopProvider();
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 {
19441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19442 }
19443 return resultobj;
19444 fail:
19445 return NULL;
19446 }
19447
19448
19449 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19450 PyObject *resultobj = 0;
19451 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19452 bool result;
19453 void *argp1 = 0 ;
19454 int res1 = 0 ;
19455 PyObject * obj0 = 0 ;
19456 char * kwnames[] = {
19457 (char *) "provider", NULL
19458 };
19459
19460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19462 if (!SWIG_IsOK(res1)) {
19463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19464 }
19465 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19466 {
19467 PyThreadState* __tstate = wxPyBeginAllowThreads();
19468 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19469 wxPyEndAllowThreads(__tstate);
19470 if (PyErr_Occurred()) SWIG_fail;
19471 }
19472 {
19473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19474 }
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19482 PyObject *resultobj = 0;
19483 wxString *arg1 = 0 ;
19484 wxString const &arg2_defvalue = wxPyART_OTHER ;
19485 wxString *arg2 = (wxString *) &arg2_defvalue ;
19486 wxSize const &arg3_defvalue = wxDefaultSize ;
19487 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19488 wxBitmap result;
19489 bool temp1 = false ;
19490 bool temp2 = false ;
19491 wxSize temp3 ;
19492 PyObject * obj0 = 0 ;
19493 PyObject * obj1 = 0 ;
19494 PyObject * obj2 = 0 ;
19495 char * kwnames[] = {
19496 (char *) "id",(char *) "client",(char *) "size", NULL
19497 };
19498
19499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19500 {
19501 arg1 = wxString_in_helper(obj0);
19502 if (arg1 == NULL) SWIG_fail;
19503 temp1 = true;
19504 }
19505 if (obj1) {
19506 {
19507 arg2 = wxString_in_helper(obj1);
19508 if (arg2 == NULL) SWIG_fail;
19509 temp2 = true;
19510 }
19511 }
19512 if (obj2) {
19513 {
19514 arg3 = &temp3;
19515 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19516 }
19517 }
19518 {
19519 if (!wxPyCheckForApp()) SWIG_fail;
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19526 {
19527 if (temp1)
19528 delete arg1;
19529 }
19530 {
19531 if (temp2)
19532 delete arg2;
19533 }
19534 return resultobj;
19535 fail:
19536 {
19537 if (temp1)
19538 delete arg1;
19539 }
19540 {
19541 if (temp2)
19542 delete arg2;
19543 }
19544 return NULL;
19545 }
19546
19547
19548 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19549 PyObject *resultobj = 0;
19550 wxString *arg1 = 0 ;
19551 wxString const &arg2_defvalue = wxPyART_OTHER ;
19552 wxString *arg2 = (wxString *) &arg2_defvalue ;
19553 wxSize const &arg3_defvalue = wxDefaultSize ;
19554 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19555 wxIcon result;
19556 bool temp1 = false ;
19557 bool temp2 = false ;
19558 wxSize temp3 ;
19559 PyObject * obj0 = 0 ;
19560 PyObject * obj1 = 0 ;
19561 PyObject * obj2 = 0 ;
19562 char * kwnames[] = {
19563 (char *) "id",(char *) "client",(char *) "size", NULL
19564 };
19565
19566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19567 {
19568 arg1 = wxString_in_helper(obj0);
19569 if (arg1 == NULL) SWIG_fail;
19570 temp1 = true;
19571 }
19572 if (obj1) {
19573 {
19574 arg2 = wxString_in_helper(obj1);
19575 if (arg2 == NULL) SWIG_fail;
19576 temp2 = true;
19577 }
19578 }
19579 if (obj2) {
19580 {
19581 arg3 = &temp3;
19582 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19583 }
19584 }
19585 {
19586 if (!wxPyCheckForApp()) SWIG_fail;
19587 PyThreadState* __tstate = wxPyBeginAllowThreads();
19588 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19593 {
19594 if (temp1)
19595 delete arg1;
19596 }
19597 {
19598 if (temp2)
19599 delete arg2;
19600 }
19601 return resultobj;
19602 fail:
19603 {
19604 if (temp1)
19605 delete arg1;
19606 }
19607 {
19608 if (temp2)
19609 delete arg2;
19610 }
19611 return NULL;
19612 }
19613
19614
19615 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19616 PyObject *resultobj = 0;
19617 wxString *arg1 = 0 ;
19618 bool arg2 = (bool) false ;
19619 wxSize result;
19620 bool temp1 = false ;
19621 bool val2 ;
19622 int ecode2 = 0 ;
19623 PyObject * obj0 = 0 ;
19624 PyObject * obj1 = 0 ;
19625 char * kwnames[] = {
19626 (char *) "client",(char *) "platform_dependent", NULL
19627 };
19628
19629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19630 {
19631 arg1 = wxString_in_helper(obj0);
19632 if (arg1 == NULL) SWIG_fail;
19633 temp1 = true;
19634 }
19635 if (obj1) {
19636 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19637 if (!SWIG_IsOK(ecode2)) {
19638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19639 }
19640 arg2 = static_cast< bool >(val2);
19641 }
19642 {
19643 PyThreadState* __tstate = wxPyBeginAllowThreads();
19644 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19649 {
19650 if (temp1)
19651 delete arg1;
19652 }
19653 return resultobj;
19654 fail:
19655 {
19656 if (temp1)
19657 delete arg1;
19658 }
19659 return NULL;
19660 }
19661
19662
19663 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19664 PyObject *resultobj = 0;
19665 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19666 void *argp1 = 0 ;
19667 int res1 = 0 ;
19668 PyObject *swig_obj[1] ;
19669
19670 if (!args) SWIG_fail;
19671 swig_obj[0] = args;
19672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19673 if (!SWIG_IsOK(res1)) {
19674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19675 }
19676 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19677 {
19678 PyThreadState* __tstate = wxPyBeginAllowThreads();
19679 wxPyArtProvider_Destroy(arg1);
19680 wxPyEndAllowThreads(__tstate);
19681 if (PyErr_Occurred()) SWIG_fail;
19682 }
19683 resultobj = SWIG_Py_Void();
19684 return resultobj;
19685 fail:
19686 return NULL;
19687 }
19688
19689
19690 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19691 PyObject *obj;
19692 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19693 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19694 return SWIG_Py_Void();
19695 }
19696
19697 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19698 return SWIG_Python_InitShadowInstance(args);
19699 }
19700
19701 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19702 PyObject *resultobj = 0;
19703 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 PyObject *swig_obj[1] ;
19707
19708 if (!args) SWIG_fail;
19709 swig_obj[0] = args;
19710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19711 if (!SWIG_IsOK(res1)) {
19712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19713 }
19714 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 delete arg1;
19718
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 resultobj = SWIG_Py_Void();
19723 return resultobj;
19724 fail:
19725 return NULL;
19726 }
19727
19728
19729 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19730 PyObject *resultobj = 0;
19731 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19732 wxConfigBase *result = 0 ;
19733 int res1 = 0 ;
19734 PyObject * obj0 = 0 ;
19735 char * kwnames[] = {
19736 (char *) "config", NULL
19737 };
19738
19739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19740 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19741 if (!SWIG_IsOK(res1)) {
19742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19743 }
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19751 return resultobj;
19752 fail:
19753 return NULL;
19754 }
19755
19756
19757 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19758 PyObject *resultobj = 0;
19759 bool arg1 = (bool) true ;
19760 wxConfigBase *result = 0 ;
19761 bool val1 ;
19762 int ecode1 = 0 ;
19763 PyObject * obj0 = 0 ;
19764 char * kwnames[] = {
19765 (char *) "createOnDemand", NULL
19766 };
19767
19768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19769 if (obj0) {
19770 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19771 if (!SWIG_IsOK(ecode1)) {
19772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19773 }
19774 arg1 = static_cast< bool >(val1);
19775 }
19776 {
19777 PyThreadState* __tstate = wxPyBeginAllowThreads();
19778 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19779 wxPyEndAllowThreads(__tstate);
19780 if (PyErr_Occurred()) SWIG_fail;
19781 }
19782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19783 return resultobj;
19784 fail:
19785 return NULL;
19786 }
19787
19788
19789 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19790 PyObject *resultobj = 0;
19791 wxConfigBase *result = 0 ;
19792
19793 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 result = (wxConfigBase *)wxConfigBase::Create();
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19801 return resultobj;
19802 fail:
19803 return NULL;
19804 }
19805
19806
19807 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19808 PyObject *resultobj = 0;
19809
19810 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19811 {
19812 PyThreadState* __tstate = wxPyBeginAllowThreads();
19813 wxConfigBase::DontCreateOnDemand();
19814 wxPyEndAllowThreads(__tstate);
19815 if (PyErr_Occurred()) SWIG_fail;
19816 }
19817 resultobj = SWIG_Py_Void();
19818 return resultobj;
19819 fail:
19820 return NULL;
19821 }
19822
19823
19824 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19825 PyObject *resultobj = 0;
19826 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19827 wxString *arg2 = 0 ;
19828 void *argp1 = 0 ;
19829 int res1 = 0 ;
19830 bool temp2 = false ;
19831 PyObject * obj0 = 0 ;
19832 PyObject * obj1 = 0 ;
19833 char * kwnames[] = {
19834 (char *) "self",(char *) "path", NULL
19835 };
19836
19837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19839 if (!SWIG_IsOK(res1)) {
19840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19841 }
19842 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19843 {
19844 arg2 = wxString_in_helper(obj1);
19845 if (arg2 == NULL) SWIG_fail;
19846 temp2 = true;
19847 }
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 (arg1)->SetPath((wxString const &)*arg2);
19851 wxPyEndAllowThreads(__tstate);
19852 if (PyErr_Occurred()) SWIG_fail;
19853 }
19854 resultobj = SWIG_Py_Void();
19855 {
19856 if (temp2)
19857 delete arg2;
19858 }
19859 return resultobj;
19860 fail:
19861 {
19862 if (temp2)
19863 delete arg2;
19864 }
19865 return NULL;
19866 }
19867
19868
19869 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19870 PyObject *resultobj = 0;
19871 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19872 wxString *result = 0 ;
19873 void *argp1 = 0 ;
19874 int res1 = 0 ;
19875 PyObject *swig_obj[1] ;
19876
19877 if (!args) SWIG_fail;
19878 swig_obj[0] = args;
19879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19880 if (!SWIG_IsOK(res1)) {
19881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19882 }
19883 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19884 {
19885 PyThreadState* __tstate = wxPyBeginAllowThreads();
19886 {
19887 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19888 result = (wxString *) &_result_ref;
19889 }
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 {
19894 #if wxUSE_UNICODE
19895 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19896 #else
19897 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19898 #endif
19899 }
19900 return resultobj;
19901 fail:
19902 return NULL;
19903 }
19904
19905
19906 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19907 PyObject *resultobj = 0;
19908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19909 PyObject *result = 0 ;
19910 void *argp1 = 0 ;
19911 int res1 = 0 ;
19912 PyObject *swig_obj[1] ;
19913
19914 if (!args) SWIG_fail;
19915 swig_obj[0] = args;
19916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19917 if (!SWIG_IsOK(res1)) {
19918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19919 }
19920 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19924 wxPyEndAllowThreads(__tstate);
19925 if (PyErr_Occurred()) SWIG_fail;
19926 }
19927 resultobj = result;
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj = 0;
19936 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19937 long arg2 ;
19938 PyObject *result = 0 ;
19939 void *argp1 = 0 ;
19940 int res1 = 0 ;
19941 long val2 ;
19942 int ecode2 = 0 ;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 char * kwnames[] = {
19946 (char *) "self",(char *) "index", NULL
19947 };
19948
19949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19951 if (!SWIG_IsOK(res1)) {
19952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19953 }
19954 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19955 ecode2 = SWIG_AsVal_long(obj1, &val2);
19956 if (!SWIG_IsOK(ecode2)) {
19957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19958 }
19959 arg2 = static_cast< long >(val2);
19960 {
19961 PyThreadState* __tstate = wxPyBeginAllowThreads();
19962 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19963 wxPyEndAllowThreads(__tstate);
19964 if (PyErr_Occurred()) SWIG_fail;
19965 }
19966 resultobj = result;
19967 return resultobj;
19968 fail:
19969 return NULL;
19970 }
19971
19972
19973 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19974 PyObject *resultobj = 0;
19975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19976 PyObject *result = 0 ;
19977 void *argp1 = 0 ;
19978 int res1 = 0 ;
19979 PyObject *swig_obj[1] ;
19980
19981 if (!args) SWIG_fail;
19982 swig_obj[0] = args;
19983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19984 if (!SWIG_IsOK(res1)) {
19985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19986 }
19987 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19988 {
19989 PyThreadState* __tstate = wxPyBeginAllowThreads();
19990 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19991 wxPyEndAllowThreads(__tstate);
19992 if (PyErr_Occurred()) SWIG_fail;
19993 }
19994 resultobj = result;
19995 return resultobj;
19996 fail:
19997 return NULL;
19998 }
19999
20000
20001 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj = 0;
20003 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20004 long arg2 ;
20005 PyObject *result = 0 ;
20006 void *argp1 = 0 ;
20007 int res1 = 0 ;
20008 long val2 ;
20009 int ecode2 = 0 ;
20010 PyObject * obj0 = 0 ;
20011 PyObject * obj1 = 0 ;
20012 char * kwnames[] = {
20013 (char *) "self",(char *) "index", NULL
20014 };
20015
20016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20018 if (!SWIG_IsOK(res1)) {
20019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20020 }
20021 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20022 ecode2 = SWIG_AsVal_long(obj1, &val2);
20023 if (!SWIG_IsOK(ecode2)) {
20024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20025 }
20026 arg2 = static_cast< long >(val2);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 resultobj = result;
20034 return resultobj;
20035 fail:
20036 return NULL;
20037 }
20038
20039
20040 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20041 PyObject *resultobj = 0;
20042 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20043 bool arg2 = (bool) false ;
20044 size_t result;
20045 void *argp1 = 0 ;
20046 int res1 = 0 ;
20047 bool val2 ;
20048 int ecode2 = 0 ;
20049 PyObject * obj0 = 0 ;
20050 PyObject * obj1 = 0 ;
20051 char * kwnames[] = {
20052 (char *) "self",(char *) "recursive", NULL
20053 };
20054
20055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20057 if (!SWIG_IsOK(res1)) {
20058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20059 }
20060 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20061 if (obj1) {
20062 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20063 if (!SWIG_IsOK(ecode2)) {
20064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20065 }
20066 arg2 = static_cast< bool >(val2);
20067 }
20068 {
20069 PyThreadState* __tstate = wxPyBeginAllowThreads();
20070 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20075 return resultobj;
20076 fail:
20077 return NULL;
20078 }
20079
20080
20081 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20082 PyObject *resultobj = 0;
20083 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20084 bool arg2 = (bool) false ;
20085 size_t result;
20086 void *argp1 = 0 ;
20087 int res1 = 0 ;
20088 bool val2 ;
20089 int ecode2 = 0 ;
20090 PyObject * obj0 = 0 ;
20091 PyObject * obj1 = 0 ;
20092 char * kwnames[] = {
20093 (char *) "self",(char *) "recursive", NULL
20094 };
20095
20096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20098 if (!SWIG_IsOK(res1)) {
20099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20100 }
20101 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20102 if (obj1) {
20103 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20104 if (!SWIG_IsOK(ecode2)) {
20105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
20106 }
20107 arg2 = static_cast< bool >(val2);
20108 }
20109 {
20110 PyThreadState* __tstate = wxPyBeginAllowThreads();
20111 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
20112 wxPyEndAllowThreads(__tstate);
20113 if (PyErr_Occurred()) SWIG_fail;
20114 }
20115 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20116 return resultobj;
20117 fail:
20118 return NULL;
20119 }
20120
20121
20122 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20123 PyObject *resultobj = 0;
20124 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20125 wxString *arg2 = 0 ;
20126 bool result;
20127 void *argp1 = 0 ;
20128 int res1 = 0 ;
20129 bool temp2 = false ;
20130 PyObject * obj0 = 0 ;
20131 PyObject * obj1 = 0 ;
20132 char * kwnames[] = {
20133 (char *) "self",(char *) "name", NULL
20134 };
20135
20136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20138 if (!SWIG_IsOK(res1)) {
20139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20140 }
20141 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20142 {
20143 arg2 = wxString_in_helper(obj1);
20144 if (arg2 == NULL) SWIG_fail;
20145 temp2 = true;
20146 }
20147 {
20148 PyThreadState* __tstate = wxPyBeginAllowThreads();
20149 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
20150 wxPyEndAllowThreads(__tstate);
20151 if (PyErr_Occurred()) SWIG_fail;
20152 }
20153 {
20154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20155 }
20156 {
20157 if (temp2)
20158 delete arg2;
20159 }
20160 return resultobj;
20161 fail:
20162 {
20163 if (temp2)
20164 delete arg2;
20165 }
20166 return NULL;
20167 }
20168
20169
20170 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20171 PyObject *resultobj = 0;
20172 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20173 wxString *arg2 = 0 ;
20174 bool result;
20175 void *argp1 = 0 ;
20176 int res1 = 0 ;
20177 bool temp2 = false ;
20178 PyObject * obj0 = 0 ;
20179 PyObject * obj1 = 0 ;
20180 char * kwnames[] = {
20181 (char *) "self",(char *) "name", NULL
20182 };
20183
20184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20186 if (!SWIG_IsOK(res1)) {
20187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20188 }
20189 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20190 {
20191 arg2 = wxString_in_helper(obj1);
20192 if (arg2 == NULL) SWIG_fail;
20193 temp2 = true;
20194 }
20195 {
20196 PyThreadState* __tstate = wxPyBeginAllowThreads();
20197 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 {
20202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20203 }
20204 {
20205 if (temp2)
20206 delete arg2;
20207 }
20208 return resultobj;
20209 fail:
20210 {
20211 if (temp2)
20212 delete arg2;
20213 }
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20219 PyObject *resultobj = 0;
20220 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20221 wxString *arg2 = 0 ;
20222 bool result;
20223 void *argp1 = 0 ;
20224 int res1 = 0 ;
20225 bool temp2 = false ;
20226 PyObject * obj0 = 0 ;
20227 PyObject * obj1 = 0 ;
20228 char * kwnames[] = {
20229 (char *) "self",(char *) "name", NULL
20230 };
20231
20232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20234 if (!SWIG_IsOK(res1)) {
20235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20236 }
20237 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20238 {
20239 arg2 = wxString_in_helper(obj1);
20240 if (arg2 == NULL) SWIG_fail;
20241 temp2 = true;
20242 }
20243 {
20244 PyThreadState* __tstate = wxPyBeginAllowThreads();
20245 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20246 wxPyEndAllowThreads(__tstate);
20247 if (PyErr_Occurred()) SWIG_fail;
20248 }
20249 {
20250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20251 }
20252 {
20253 if (temp2)
20254 delete arg2;
20255 }
20256 return resultobj;
20257 fail:
20258 {
20259 if (temp2)
20260 delete arg2;
20261 }
20262 return NULL;
20263 }
20264
20265
20266 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20267 PyObject *resultobj = 0;
20268 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20269 wxString *arg2 = 0 ;
20270 wxConfigBase::EntryType result;
20271 void *argp1 = 0 ;
20272 int res1 = 0 ;
20273 bool temp2 = false ;
20274 PyObject * obj0 = 0 ;
20275 PyObject * obj1 = 0 ;
20276 char * kwnames[] = {
20277 (char *) "self",(char *) "name", NULL
20278 };
20279
20280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20282 if (!SWIG_IsOK(res1)) {
20283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20284 }
20285 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20286 {
20287 arg2 = wxString_in_helper(obj1);
20288 if (arg2 == NULL) SWIG_fail;
20289 temp2 = true;
20290 }
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 resultobj = SWIG_From_int(static_cast< int >(result));
20298 {
20299 if (temp2)
20300 delete arg2;
20301 }
20302 return resultobj;
20303 fail:
20304 {
20305 if (temp2)
20306 delete arg2;
20307 }
20308 return NULL;
20309 }
20310
20311
20312 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20313 PyObject *resultobj = 0;
20314 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20315 wxString *arg2 = 0 ;
20316 wxString const &arg3_defvalue = wxPyEmptyString ;
20317 wxString *arg3 = (wxString *) &arg3_defvalue ;
20318 wxString result;
20319 void *argp1 = 0 ;
20320 int res1 = 0 ;
20321 bool temp2 = false ;
20322 bool temp3 = false ;
20323 PyObject * obj0 = 0 ;
20324 PyObject * obj1 = 0 ;
20325 PyObject * obj2 = 0 ;
20326 char * kwnames[] = {
20327 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20328 };
20329
20330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20332 if (!SWIG_IsOK(res1)) {
20333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20334 }
20335 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20336 {
20337 arg2 = wxString_in_helper(obj1);
20338 if (arg2 == NULL) SWIG_fail;
20339 temp2 = true;
20340 }
20341 if (obj2) {
20342 {
20343 arg3 = wxString_in_helper(obj2);
20344 if (arg3 == NULL) SWIG_fail;
20345 temp3 = true;
20346 }
20347 }
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20351 wxPyEndAllowThreads(__tstate);
20352 if (PyErr_Occurred()) SWIG_fail;
20353 }
20354 {
20355 #if wxUSE_UNICODE
20356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20357 #else
20358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20359 #endif
20360 }
20361 {
20362 if (temp2)
20363 delete arg2;
20364 }
20365 {
20366 if (temp3)
20367 delete arg3;
20368 }
20369 return resultobj;
20370 fail:
20371 {
20372 if (temp2)
20373 delete arg2;
20374 }
20375 {
20376 if (temp3)
20377 delete arg3;
20378 }
20379 return NULL;
20380 }
20381
20382
20383 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20384 PyObject *resultobj = 0;
20385 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20386 wxString *arg2 = 0 ;
20387 long arg3 = (long) 0 ;
20388 long result;
20389 void *argp1 = 0 ;
20390 int res1 = 0 ;
20391 bool temp2 = false ;
20392 long val3 ;
20393 int ecode3 = 0 ;
20394 PyObject * obj0 = 0 ;
20395 PyObject * obj1 = 0 ;
20396 PyObject * obj2 = 0 ;
20397 char * kwnames[] = {
20398 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20399 };
20400
20401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20403 if (!SWIG_IsOK(res1)) {
20404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20405 }
20406 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20407 {
20408 arg2 = wxString_in_helper(obj1);
20409 if (arg2 == NULL) SWIG_fail;
20410 temp2 = true;
20411 }
20412 if (obj2) {
20413 ecode3 = SWIG_AsVal_long(obj2, &val3);
20414 if (!SWIG_IsOK(ecode3)) {
20415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20416 }
20417 arg3 = static_cast< long >(val3);
20418 }
20419 {
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 resultobj = SWIG_From_long(static_cast< long >(result));
20426 {
20427 if (temp2)
20428 delete arg2;
20429 }
20430 return resultobj;
20431 fail:
20432 {
20433 if (temp2)
20434 delete arg2;
20435 }
20436 return NULL;
20437 }
20438
20439
20440 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20441 PyObject *resultobj = 0;
20442 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20443 wxString *arg2 = 0 ;
20444 double arg3 = (double) 0.0 ;
20445 double result;
20446 void *argp1 = 0 ;
20447 int res1 = 0 ;
20448 bool temp2 = false ;
20449 double val3 ;
20450 int ecode3 = 0 ;
20451 PyObject * obj0 = 0 ;
20452 PyObject * obj1 = 0 ;
20453 PyObject * obj2 = 0 ;
20454 char * kwnames[] = {
20455 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20456 };
20457
20458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20460 if (!SWIG_IsOK(res1)) {
20461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20462 }
20463 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20464 {
20465 arg2 = wxString_in_helper(obj1);
20466 if (arg2 == NULL) SWIG_fail;
20467 temp2 = true;
20468 }
20469 if (obj2) {
20470 ecode3 = SWIG_AsVal_double(obj2, &val3);
20471 if (!SWIG_IsOK(ecode3)) {
20472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20473 }
20474 arg3 = static_cast< double >(val3);
20475 }
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 resultobj = SWIG_From_double(static_cast< double >(result));
20483 {
20484 if (temp2)
20485 delete arg2;
20486 }
20487 return resultobj;
20488 fail:
20489 {
20490 if (temp2)
20491 delete arg2;
20492 }
20493 return NULL;
20494 }
20495
20496
20497 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20498 PyObject *resultobj = 0;
20499 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20500 wxString *arg2 = 0 ;
20501 bool arg3 = (bool) false ;
20502 bool result;
20503 void *argp1 = 0 ;
20504 int res1 = 0 ;
20505 bool temp2 = false ;
20506 bool val3 ;
20507 int ecode3 = 0 ;
20508 PyObject * obj0 = 0 ;
20509 PyObject * obj1 = 0 ;
20510 PyObject * obj2 = 0 ;
20511 char * kwnames[] = {
20512 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20513 };
20514
20515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20517 if (!SWIG_IsOK(res1)) {
20518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20519 }
20520 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20521 {
20522 arg2 = wxString_in_helper(obj1);
20523 if (arg2 == NULL) SWIG_fail;
20524 temp2 = true;
20525 }
20526 if (obj2) {
20527 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20528 if (!SWIG_IsOK(ecode3)) {
20529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20530 }
20531 arg3 = static_cast< bool >(val3);
20532 }
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20536 wxPyEndAllowThreads(__tstate);
20537 if (PyErr_Occurred()) SWIG_fail;
20538 }
20539 {
20540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20541 }
20542 {
20543 if (temp2)
20544 delete arg2;
20545 }
20546 return resultobj;
20547 fail:
20548 {
20549 if (temp2)
20550 delete arg2;
20551 }
20552 return NULL;
20553 }
20554
20555
20556 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20557 PyObject *resultobj = 0;
20558 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20559 wxString *arg2 = 0 ;
20560 wxString *arg3 = 0 ;
20561 bool result;
20562 void *argp1 = 0 ;
20563 int res1 = 0 ;
20564 bool temp2 = false ;
20565 bool temp3 = false ;
20566 PyObject * obj0 = 0 ;
20567 PyObject * obj1 = 0 ;
20568 PyObject * obj2 = 0 ;
20569 char * kwnames[] = {
20570 (char *) "self",(char *) "key",(char *) "value", NULL
20571 };
20572
20573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20575 if (!SWIG_IsOK(res1)) {
20576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20577 }
20578 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20579 {
20580 arg2 = wxString_in_helper(obj1);
20581 if (arg2 == NULL) SWIG_fail;
20582 temp2 = true;
20583 }
20584 {
20585 arg3 = wxString_in_helper(obj2);
20586 if (arg3 == NULL) SWIG_fail;
20587 temp3 = true;
20588 }
20589 {
20590 PyThreadState* __tstate = wxPyBeginAllowThreads();
20591 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 {
20596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20597 }
20598 {
20599 if (temp2)
20600 delete arg2;
20601 }
20602 {
20603 if (temp3)
20604 delete arg3;
20605 }
20606 return resultobj;
20607 fail:
20608 {
20609 if (temp2)
20610 delete arg2;
20611 }
20612 {
20613 if (temp3)
20614 delete arg3;
20615 }
20616 return NULL;
20617 }
20618
20619
20620 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj = 0;
20622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20623 wxString *arg2 = 0 ;
20624 long arg3 ;
20625 bool result;
20626 void *argp1 = 0 ;
20627 int res1 = 0 ;
20628 bool temp2 = false ;
20629 long val3 ;
20630 int ecode3 = 0 ;
20631 PyObject * obj0 = 0 ;
20632 PyObject * obj1 = 0 ;
20633 PyObject * obj2 = 0 ;
20634 char * kwnames[] = {
20635 (char *) "self",(char *) "key",(char *) "value", NULL
20636 };
20637
20638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20640 if (!SWIG_IsOK(res1)) {
20641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20642 }
20643 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20644 {
20645 arg2 = wxString_in_helper(obj1);
20646 if (arg2 == NULL) SWIG_fail;
20647 temp2 = true;
20648 }
20649 ecode3 = SWIG_AsVal_long(obj2, &val3);
20650 if (!SWIG_IsOK(ecode3)) {
20651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20652 }
20653 arg3 = static_cast< long >(val3);
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 {
20661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20662 }
20663 {
20664 if (temp2)
20665 delete arg2;
20666 }
20667 return resultobj;
20668 fail:
20669 {
20670 if (temp2)
20671 delete arg2;
20672 }
20673 return NULL;
20674 }
20675
20676
20677 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20678 PyObject *resultobj = 0;
20679 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20680 wxString *arg2 = 0 ;
20681 double arg3 ;
20682 bool result;
20683 void *argp1 = 0 ;
20684 int res1 = 0 ;
20685 bool temp2 = false ;
20686 double val3 ;
20687 int ecode3 = 0 ;
20688 PyObject * obj0 = 0 ;
20689 PyObject * obj1 = 0 ;
20690 PyObject * obj2 = 0 ;
20691 char * kwnames[] = {
20692 (char *) "self",(char *) "key",(char *) "value", NULL
20693 };
20694
20695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20697 if (!SWIG_IsOK(res1)) {
20698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20699 }
20700 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20701 {
20702 arg2 = wxString_in_helper(obj1);
20703 if (arg2 == NULL) SWIG_fail;
20704 temp2 = true;
20705 }
20706 ecode3 = SWIG_AsVal_double(obj2, &val3);
20707 if (!SWIG_IsOK(ecode3)) {
20708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20709 }
20710 arg3 = static_cast< double >(val3);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 {
20718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20719 }
20720 {
20721 if (temp2)
20722 delete arg2;
20723 }
20724 return resultobj;
20725 fail:
20726 {
20727 if (temp2)
20728 delete arg2;
20729 }
20730 return NULL;
20731 }
20732
20733
20734 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj = 0;
20736 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20737 wxString *arg2 = 0 ;
20738 bool arg3 ;
20739 bool result;
20740 void *argp1 = 0 ;
20741 int res1 = 0 ;
20742 bool temp2 = false ;
20743 bool val3 ;
20744 int ecode3 = 0 ;
20745 PyObject * obj0 = 0 ;
20746 PyObject * obj1 = 0 ;
20747 PyObject * obj2 = 0 ;
20748 char * kwnames[] = {
20749 (char *) "self",(char *) "key",(char *) "value", NULL
20750 };
20751
20752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20754 if (!SWIG_IsOK(res1)) {
20755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20756 }
20757 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20758 {
20759 arg2 = wxString_in_helper(obj1);
20760 if (arg2 == NULL) SWIG_fail;
20761 temp2 = true;
20762 }
20763 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20764 if (!SWIG_IsOK(ecode3)) {
20765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20766 }
20767 arg3 = static_cast< bool >(val3);
20768 {
20769 PyThreadState* __tstate = wxPyBeginAllowThreads();
20770 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20771 wxPyEndAllowThreads(__tstate);
20772 if (PyErr_Occurred()) SWIG_fail;
20773 }
20774 {
20775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20776 }
20777 {
20778 if (temp2)
20779 delete arg2;
20780 }
20781 return resultobj;
20782 fail:
20783 {
20784 if (temp2)
20785 delete arg2;
20786 }
20787 return NULL;
20788 }
20789
20790
20791 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20792 PyObject *resultobj = 0;
20793 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20794 bool arg2 = (bool) false ;
20795 bool result;
20796 void *argp1 = 0 ;
20797 int res1 = 0 ;
20798 bool val2 ;
20799 int ecode2 = 0 ;
20800 PyObject * obj0 = 0 ;
20801 PyObject * obj1 = 0 ;
20802 char * kwnames[] = {
20803 (char *) "self",(char *) "currentOnly", NULL
20804 };
20805
20806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20808 if (!SWIG_IsOK(res1)) {
20809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20810 }
20811 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20812 if (obj1) {
20813 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20814 if (!SWIG_IsOK(ecode2)) {
20815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20816 }
20817 arg2 = static_cast< bool >(val2);
20818 }
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (bool)(arg1)->Flush(arg2);
20822 wxPyEndAllowThreads(__tstate);
20823 if (PyErr_Occurred()) SWIG_fail;
20824 }
20825 {
20826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20827 }
20828 return resultobj;
20829 fail:
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20835 PyObject *resultobj = 0;
20836 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20837 wxString *arg2 = 0 ;
20838 wxString *arg3 = 0 ;
20839 bool result;
20840 void *argp1 = 0 ;
20841 int res1 = 0 ;
20842 bool temp2 = false ;
20843 bool temp3 = false ;
20844 PyObject * obj0 = 0 ;
20845 PyObject * obj1 = 0 ;
20846 PyObject * obj2 = 0 ;
20847 char * kwnames[] = {
20848 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20849 };
20850
20851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20853 if (!SWIG_IsOK(res1)) {
20854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20855 }
20856 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20857 {
20858 arg2 = wxString_in_helper(obj1);
20859 if (arg2 == NULL) SWIG_fail;
20860 temp2 = true;
20861 }
20862 {
20863 arg3 = wxString_in_helper(obj2);
20864 if (arg3 == NULL) SWIG_fail;
20865 temp3 = true;
20866 }
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 {
20874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20875 }
20876 {
20877 if (temp2)
20878 delete arg2;
20879 }
20880 {
20881 if (temp3)
20882 delete arg3;
20883 }
20884 return resultobj;
20885 fail:
20886 {
20887 if (temp2)
20888 delete arg2;
20889 }
20890 {
20891 if (temp3)
20892 delete arg3;
20893 }
20894 return NULL;
20895 }
20896
20897
20898 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20899 PyObject *resultobj = 0;
20900 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20901 wxString *arg2 = 0 ;
20902 wxString *arg3 = 0 ;
20903 bool result;
20904 void *argp1 = 0 ;
20905 int res1 = 0 ;
20906 bool temp2 = false ;
20907 bool temp3 = false ;
20908 PyObject * obj0 = 0 ;
20909 PyObject * obj1 = 0 ;
20910 PyObject * obj2 = 0 ;
20911 char * kwnames[] = {
20912 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20913 };
20914
20915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20917 if (!SWIG_IsOK(res1)) {
20918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20919 }
20920 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20921 {
20922 arg2 = wxString_in_helper(obj1);
20923 if (arg2 == NULL) SWIG_fail;
20924 temp2 = true;
20925 }
20926 {
20927 arg3 = wxString_in_helper(obj2);
20928 if (arg3 == NULL) SWIG_fail;
20929 temp3 = true;
20930 }
20931 {
20932 PyThreadState* __tstate = wxPyBeginAllowThreads();
20933 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20934 wxPyEndAllowThreads(__tstate);
20935 if (PyErr_Occurred()) SWIG_fail;
20936 }
20937 {
20938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20939 }
20940 {
20941 if (temp2)
20942 delete arg2;
20943 }
20944 {
20945 if (temp3)
20946 delete arg3;
20947 }
20948 return resultobj;
20949 fail:
20950 {
20951 if (temp2)
20952 delete arg2;
20953 }
20954 {
20955 if (temp3)
20956 delete arg3;
20957 }
20958 return NULL;
20959 }
20960
20961
20962 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20963 PyObject *resultobj = 0;
20964 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20965 wxString *arg2 = 0 ;
20966 bool arg3 = (bool) true ;
20967 bool result;
20968 void *argp1 = 0 ;
20969 int res1 = 0 ;
20970 bool temp2 = false ;
20971 bool val3 ;
20972 int ecode3 = 0 ;
20973 PyObject * obj0 = 0 ;
20974 PyObject * obj1 = 0 ;
20975 PyObject * obj2 = 0 ;
20976 char * kwnames[] = {
20977 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20978 };
20979
20980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20982 if (!SWIG_IsOK(res1)) {
20983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20984 }
20985 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20986 {
20987 arg2 = wxString_in_helper(obj1);
20988 if (arg2 == NULL) SWIG_fail;
20989 temp2 = true;
20990 }
20991 if (obj2) {
20992 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20993 if (!SWIG_IsOK(ecode3)) {
20994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20995 }
20996 arg3 = static_cast< bool >(val3);
20997 }
20998 {
20999 PyThreadState* __tstate = wxPyBeginAllowThreads();
21000 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21001 wxPyEndAllowThreads(__tstate);
21002 if (PyErr_Occurred()) SWIG_fail;
21003 }
21004 {
21005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21006 }
21007 {
21008 if (temp2)
21009 delete arg2;
21010 }
21011 return resultobj;
21012 fail:
21013 {
21014 if (temp2)
21015 delete arg2;
21016 }
21017 return NULL;
21018 }
21019
21020
21021 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21022 PyObject *resultobj = 0;
21023 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21024 wxString *arg2 = 0 ;
21025 bool result;
21026 void *argp1 = 0 ;
21027 int res1 = 0 ;
21028 bool temp2 = false ;
21029 PyObject * obj0 = 0 ;
21030 PyObject * obj1 = 0 ;
21031 char * kwnames[] = {
21032 (char *) "self",(char *) "key", NULL
21033 };
21034
21035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21037 if (!SWIG_IsOK(res1)) {
21038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21039 }
21040 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21041 {
21042 arg2 = wxString_in_helper(obj1);
21043 if (arg2 == NULL) SWIG_fail;
21044 temp2 = true;
21045 }
21046 {
21047 PyThreadState* __tstate = wxPyBeginAllowThreads();
21048 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 {
21053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21054 }
21055 {
21056 if (temp2)
21057 delete arg2;
21058 }
21059 return resultobj;
21060 fail:
21061 {
21062 if (temp2)
21063 delete arg2;
21064 }
21065 return NULL;
21066 }
21067
21068
21069 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21070 PyObject *resultobj = 0;
21071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21072 bool result;
21073 void *argp1 = 0 ;
21074 int res1 = 0 ;
21075 PyObject *swig_obj[1] ;
21076
21077 if (!args) SWIG_fail;
21078 swig_obj[0] = args;
21079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21080 if (!SWIG_IsOK(res1)) {
21081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21082 }
21083 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 result = (bool)(arg1)->DeleteAll();
21087 wxPyEndAllowThreads(__tstate);
21088 if (PyErr_Occurred()) SWIG_fail;
21089 }
21090 {
21091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21092 }
21093 return resultobj;
21094 fail:
21095 return NULL;
21096 }
21097
21098
21099 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21100 PyObject *resultobj = 0;
21101 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21102 bool arg2 = (bool) true ;
21103 void *argp1 = 0 ;
21104 int res1 = 0 ;
21105 bool val2 ;
21106 int ecode2 = 0 ;
21107 PyObject * obj0 = 0 ;
21108 PyObject * obj1 = 0 ;
21109 char * kwnames[] = {
21110 (char *) "self",(char *) "doIt", NULL
21111 };
21112
21113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21115 if (!SWIG_IsOK(res1)) {
21116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21117 }
21118 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21119 if (obj1) {
21120 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21121 if (!SWIG_IsOK(ecode2)) {
21122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
21123 }
21124 arg2 = static_cast< bool >(val2);
21125 }
21126 {
21127 PyThreadState* __tstate = wxPyBeginAllowThreads();
21128 (arg1)->SetExpandEnvVars(arg2);
21129 wxPyEndAllowThreads(__tstate);
21130 if (PyErr_Occurred()) SWIG_fail;
21131 }
21132 resultobj = SWIG_Py_Void();
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21140 PyObject *resultobj = 0;
21141 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21142 bool result;
21143 void *argp1 = 0 ;
21144 int res1 = 0 ;
21145 PyObject *swig_obj[1] ;
21146
21147 if (!args) SWIG_fail;
21148 swig_obj[0] = args;
21149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21150 if (!SWIG_IsOK(res1)) {
21151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21152 }
21153 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21154 {
21155 PyThreadState* __tstate = wxPyBeginAllowThreads();
21156 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
21157 wxPyEndAllowThreads(__tstate);
21158 if (PyErr_Occurred()) SWIG_fail;
21159 }
21160 {
21161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21162 }
21163 return resultobj;
21164 fail:
21165 return NULL;
21166 }
21167
21168
21169 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21170 PyObject *resultobj = 0;
21171 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21172 bool arg2 = (bool) true ;
21173 void *argp1 = 0 ;
21174 int res1 = 0 ;
21175 bool val2 ;
21176 int ecode2 = 0 ;
21177 PyObject * obj0 = 0 ;
21178 PyObject * obj1 = 0 ;
21179 char * kwnames[] = {
21180 (char *) "self",(char *) "doIt", NULL
21181 };
21182
21183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21187 }
21188 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21189 if (obj1) {
21190 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21191 if (!SWIG_IsOK(ecode2)) {
21192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21193 }
21194 arg2 = static_cast< bool >(val2);
21195 }
21196 {
21197 PyThreadState* __tstate = wxPyBeginAllowThreads();
21198 (arg1)->SetRecordDefaults(arg2);
21199 wxPyEndAllowThreads(__tstate);
21200 if (PyErr_Occurred()) SWIG_fail;
21201 }
21202 resultobj = SWIG_Py_Void();
21203 return resultobj;
21204 fail:
21205 return NULL;
21206 }
21207
21208
21209 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21210 PyObject *resultobj = 0;
21211 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21212 bool result;
21213 void *argp1 = 0 ;
21214 int res1 = 0 ;
21215 PyObject *swig_obj[1] ;
21216
21217 if (!args) SWIG_fail;
21218 swig_obj[0] = args;
21219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21222 }
21223 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21224 {
21225 PyThreadState* __tstate = wxPyBeginAllowThreads();
21226 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21227 wxPyEndAllowThreads(__tstate);
21228 if (PyErr_Occurred()) SWIG_fail;
21229 }
21230 {
21231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21232 }
21233 return resultobj;
21234 fail:
21235 return NULL;
21236 }
21237
21238
21239 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21240 PyObject *resultobj = 0;
21241 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21242 wxString *arg2 = 0 ;
21243 wxString result;
21244 void *argp1 = 0 ;
21245 int res1 = 0 ;
21246 bool temp2 = false ;
21247 PyObject * obj0 = 0 ;
21248 PyObject * obj1 = 0 ;
21249 char * kwnames[] = {
21250 (char *) "self",(char *) "str", NULL
21251 };
21252
21253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21255 if (!SWIG_IsOK(res1)) {
21256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21257 }
21258 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21259 {
21260 arg2 = wxString_in_helper(obj1);
21261 if (arg2 == NULL) SWIG_fail;
21262 temp2 = true;
21263 }
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21267 wxPyEndAllowThreads(__tstate);
21268 if (PyErr_Occurred()) SWIG_fail;
21269 }
21270 {
21271 #if wxUSE_UNICODE
21272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21273 #else
21274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21275 #endif
21276 }
21277 {
21278 if (temp2)
21279 delete arg2;
21280 }
21281 return resultobj;
21282 fail:
21283 {
21284 if (temp2)
21285 delete arg2;
21286 }
21287 return NULL;
21288 }
21289
21290
21291 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21292 PyObject *resultobj = 0;
21293 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21294 wxString result;
21295 void *argp1 = 0 ;
21296 int res1 = 0 ;
21297 PyObject *swig_obj[1] ;
21298
21299 if (!args) SWIG_fail;
21300 swig_obj[0] = args;
21301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21302 if (!SWIG_IsOK(res1)) {
21303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21304 }
21305 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21306 {
21307 PyThreadState* __tstate = wxPyBeginAllowThreads();
21308 result = ((wxConfigBase const *)arg1)->GetAppName();
21309 wxPyEndAllowThreads(__tstate);
21310 if (PyErr_Occurred()) SWIG_fail;
21311 }
21312 {
21313 #if wxUSE_UNICODE
21314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21315 #else
21316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21317 #endif
21318 }
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21326 PyObject *resultobj = 0;
21327 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21328 wxString result;
21329 void *argp1 = 0 ;
21330 int res1 = 0 ;
21331 PyObject *swig_obj[1] ;
21332
21333 if (!args) SWIG_fail;
21334 swig_obj[0] = args;
21335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21336 if (!SWIG_IsOK(res1)) {
21337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21338 }
21339 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21340 {
21341 PyThreadState* __tstate = wxPyBeginAllowThreads();
21342 result = ((wxConfigBase const *)arg1)->GetVendorName();
21343 wxPyEndAllowThreads(__tstate);
21344 if (PyErr_Occurred()) SWIG_fail;
21345 }
21346 {
21347 #if wxUSE_UNICODE
21348 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21349 #else
21350 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21351 #endif
21352 }
21353 return resultobj;
21354 fail:
21355 return NULL;
21356 }
21357
21358
21359 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21360 PyObject *resultobj = 0;
21361 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21362 wxString *arg2 = 0 ;
21363 void *argp1 = 0 ;
21364 int res1 = 0 ;
21365 bool temp2 = false ;
21366 PyObject * obj0 = 0 ;
21367 PyObject * obj1 = 0 ;
21368 char * kwnames[] = {
21369 (char *) "self",(char *) "appName", NULL
21370 };
21371
21372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21374 if (!SWIG_IsOK(res1)) {
21375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21376 }
21377 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21378 {
21379 arg2 = wxString_in_helper(obj1);
21380 if (arg2 == NULL) SWIG_fail;
21381 temp2 = true;
21382 }
21383 {
21384 PyThreadState* __tstate = wxPyBeginAllowThreads();
21385 (arg1)->SetAppName((wxString const &)*arg2);
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 resultobj = SWIG_Py_Void();
21390 {
21391 if (temp2)
21392 delete arg2;
21393 }
21394 return resultobj;
21395 fail:
21396 {
21397 if (temp2)
21398 delete arg2;
21399 }
21400 return NULL;
21401 }
21402
21403
21404 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21405 PyObject *resultobj = 0;
21406 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21407 wxString *arg2 = 0 ;
21408 void *argp1 = 0 ;
21409 int res1 = 0 ;
21410 bool temp2 = false ;
21411 PyObject * obj0 = 0 ;
21412 PyObject * obj1 = 0 ;
21413 char * kwnames[] = {
21414 (char *) "self",(char *) "vendorName", NULL
21415 };
21416
21417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21419 if (!SWIG_IsOK(res1)) {
21420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21421 }
21422 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21423 {
21424 arg2 = wxString_in_helper(obj1);
21425 if (arg2 == NULL) SWIG_fail;
21426 temp2 = true;
21427 }
21428 {
21429 PyThreadState* __tstate = wxPyBeginAllowThreads();
21430 (arg1)->SetVendorName((wxString const &)*arg2);
21431 wxPyEndAllowThreads(__tstate);
21432 if (PyErr_Occurred()) SWIG_fail;
21433 }
21434 resultobj = SWIG_Py_Void();
21435 {
21436 if (temp2)
21437 delete arg2;
21438 }
21439 return resultobj;
21440 fail:
21441 {
21442 if (temp2)
21443 delete arg2;
21444 }
21445 return NULL;
21446 }
21447
21448
21449 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21450 PyObject *resultobj = 0;
21451 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21452 long arg2 ;
21453 void *argp1 = 0 ;
21454 int res1 = 0 ;
21455 long val2 ;
21456 int ecode2 = 0 ;
21457 PyObject * obj0 = 0 ;
21458 PyObject * obj1 = 0 ;
21459 char * kwnames[] = {
21460 (char *) "self",(char *) "style", NULL
21461 };
21462
21463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21465 if (!SWIG_IsOK(res1)) {
21466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21467 }
21468 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21469 ecode2 = SWIG_AsVal_long(obj1, &val2);
21470 if (!SWIG_IsOK(ecode2)) {
21471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21472 }
21473 arg2 = static_cast< long >(val2);
21474 {
21475 PyThreadState* __tstate = wxPyBeginAllowThreads();
21476 (arg1)->SetStyle(arg2);
21477 wxPyEndAllowThreads(__tstate);
21478 if (PyErr_Occurred()) SWIG_fail;
21479 }
21480 resultobj = SWIG_Py_Void();
21481 return resultobj;
21482 fail:
21483 return NULL;
21484 }
21485
21486
21487 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21488 PyObject *resultobj = 0;
21489 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21490 long result;
21491 void *argp1 = 0 ;
21492 int res1 = 0 ;
21493 PyObject *swig_obj[1] ;
21494
21495 if (!args) SWIG_fail;
21496 swig_obj[0] = args;
21497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21498 if (!SWIG_IsOK(res1)) {
21499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21500 }
21501 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21502 {
21503 PyThreadState* __tstate = wxPyBeginAllowThreads();
21504 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21505 wxPyEndAllowThreads(__tstate);
21506 if (PyErr_Occurred()) SWIG_fail;
21507 }
21508 resultobj = SWIG_From_long(static_cast< long >(result));
21509 return resultobj;
21510 fail:
21511 return NULL;
21512 }
21513
21514
21515 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21516 PyObject *obj;
21517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21518 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21519 return SWIG_Py_Void();
21520 }
21521
21522 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21523 PyObject *resultobj = 0;
21524 wxString const &arg1_defvalue = wxPyEmptyString ;
21525 wxString *arg1 = (wxString *) &arg1_defvalue ;
21526 wxString const &arg2_defvalue = wxPyEmptyString ;
21527 wxString *arg2 = (wxString *) &arg2_defvalue ;
21528 wxString const &arg3_defvalue = wxPyEmptyString ;
21529 wxString *arg3 = (wxString *) &arg3_defvalue ;
21530 wxString const &arg4_defvalue = wxPyEmptyString ;
21531 wxString *arg4 = (wxString *) &arg4_defvalue ;
21532 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21533 wxConfig *result = 0 ;
21534 bool temp1 = false ;
21535 bool temp2 = false ;
21536 bool temp3 = false ;
21537 bool temp4 = false ;
21538 long val5 ;
21539 int ecode5 = 0 ;
21540 PyObject * obj0 = 0 ;
21541 PyObject * obj1 = 0 ;
21542 PyObject * obj2 = 0 ;
21543 PyObject * obj3 = 0 ;
21544 PyObject * obj4 = 0 ;
21545 char * kwnames[] = {
21546 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21547 };
21548
21549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21550 if (obj0) {
21551 {
21552 arg1 = wxString_in_helper(obj0);
21553 if (arg1 == NULL) SWIG_fail;
21554 temp1 = true;
21555 }
21556 }
21557 if (obj1) {
21558 {
21559 arg2 = wxString_in_helper(obj1);
21560 if (arg2 == NULL) SWIG_fail;
21561 temp2 = true;
21562 }
21563 }
21564 if (obj2) {
21565 {
21566 arg3 = wxString_in_helper(obj2);
21567 if (arg3 == NULL) SWIG_fail;
21568 temp3 = true;
21569 }
21570 }
21571 if (obj3) {
21572 {
21573 arg4 = wxString_in_helper(obj3);
21574 if (arg4 == NULL) SWIG_fail;
21575 temp4 = true;
21576 }
21577 }
21578 if (obj4) {
21579 ecode5 = SWIG_AsVal_long(obj4, &val5);
21580 if (!SWIG_IsOK(ecode5)) {
21581 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21582 }
21583 arg5 = static_cast< long >(val5);
21584 }
21585 {
21586 PyThreadState* __tstate = wxPyBeginAllowThreads();
21587 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21588 wxPyEndAllowThreads(__tstate);
21589 if (PyErr_Occurred()) SWIG_fail;
21590 }
21591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21592 {
21593 if (temp1)
21594 delete arg1;
21595 }
21596 {
21597 if (temp2)
21598 delete arg2;
21599 }
21600 {
21601 if (temp3)
21602 delete arg3;
21603 }
21604 {
21605 if (temp4)
21606 delete arg4;
21607 }
21608 return resultobj;
21609 fail:
21610 {
21611 if (temp1)
21612 delete arg1;
21613 }
21614 {
21615 if (temp2)
21616 delete arg2;
21617 }
21618 {
21619 if (temp3)
21620 delete arg3;
21621 }
21622 {
21623 if (temp4)
21624 delete arg4;
21625 }
21626 return NULL;
21627 }
21628
21629
21630 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21631 PyObject *resultobj = 0;
21632 wxConfig *arg1 = (wxConfig *) 0 ;
21633 void *argp1 = 0 ;
21634 int res1 = 0 ;
21635 PyObject *swig_obj[1] ;
21636
21637 if (!args) SWIG_fail;
21638 swig_obj[0] = args;
21639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21640 if (!SWIG_IsOK(res1)) {
21641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21642 }
21643 arg1 = reinterpret_cast< wxConfig * >(argp1);
21644 {
21645 PyThreadState* __tstate = wxPyBeginAllowThreads();
21646 delete arg1;
21647
21648 wxPyEndAllowThreads(__tstate);
21649 if (PyErr_Occurred()) SWIG_fail;
21650 }
21651 resultobj = SWIG_Py_Void();
21652 return resultobj;
21653 fail:
21654 return NULL;
21655 }
21656
21657
21658 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21659 PyObject *obj;
21660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21661 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21662 return SWIG_Py_Void();
21663 }
21664
21665 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21666 return SWIG_Python_InitShadowInstance(args);
21667 }
21668
21669 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21670 PyObject *resultobj = 0;
21671 wxString const &arg1_defvalue = wxPyEmptyString ;
21672 wxString *arg1 = (wxString *) &arg1_defvalue ;
21673 wxString const &arg2_defvalue = wxPyEmptyString ;
21674 wxString *arg2 = (wxString *) &arg2_defvalue ;
21675 wxString const &arg3_defvalue = wxPyEmptyString ;
21676 wxString *arg3 = (wxString *) &arg3_defvalue ;
21677 wxString const &arg4_defvalue = wxPyEmptyString ;
21678 wxString *arg4 = (wxString *) &arg4_defvalue ;
21679 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21680 wxFileConfig *result = 0 ;
21681 bool temp1 = false ;
21682 bool temp2 = false ;
21683 bool temp3 = false ;
21684 bool temp4 = false ;
21685 long val5 ;
21686 int ecode5 = 0 ;
21687 PyObject * obj0 = 0 ;
21688 PyObject * obj1 = 0 ;
21689 PyObject * obj2 = 0 ;
21690 PyObject * obj3 = 0 ;
21691 PyObject * obj4 = 0 ;
21692 char * kwnames[] = {
21693 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21694 };
21695
21696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21697 if (obj0) {
21698 {
21699 arg1 = wxString_in_helper(obj0);
21700 if (arg1 == NULL) SWIG_fail;
21701 temp1 = true;
21702 }
21703 }
21704 if (obj1) {
21705 {
21706 arg2 = wxString_in_helper(obj1);
21707 if (arg2 == NULL) SWIG_fail;
21708 temp2 = true;
21709 }
21710 }
21711 if (obj2) {
21712 {
21713 arg3 = wxString_in_helper(obj2);
21714 if (arg3 == NULL) SWIG_fail;
21715 temp3 = true;
21716 }
21717 }
21718 if (obj3) {
21719 {
21720 arg4 = wxString_in_helper(obj3);
21721 if (arg4 == NULL) SWIG_fail;
21722 temp4 = true;
21723 }
21724 }
21725 if (obj4) {
21726 ecode5 = SWIG_AsVal_long(obj4, &val5);
21727 if (!SWIG_IsOK(ecode5)) {
21728 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21729 }
21730 arg5 = static_cast< long >(val5);
21731 }
21732 {
21733 PyThreadState* __tstate = wxPyBeginAllowThreads();
21734 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21735 wxPyEndAllowThreads(__tstate);
21736 if (PyErr_Occurred()) SWIG_fail;
21737 }
21738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21739 {
21740 if (temp1)
21741 delete arg1;
21742 }
21743 {
21744 if (temp2)
21745 delete arg2;
21746 }
21747 {
21748 if (temp3)
21749 delete arg3;
21750 }
21751 {
21752 if (temp4)
21753 delete arg4;
21754 }
21755 return resultobj;
21756 fail:
21757 {
21758 if (temp1)
21759 delete arg1;
21760 }
21761 {
21762 if (temp2)
21763 delete arg2;
21764 }
21765 {
21766 if (temp3)
21767 delete arg3;
21768 }
21769 {
21770 if (temp4)
21771 delete arg4;
21772 }
21773 return NULL;
21774 }
21775
21776
21777 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21778 PyObject *resultobj = 0;
21779 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21780 void *argp1 = 0 ;
21781 int res1 = 0 ;
21782 PyObject *swig_obj[1] ;
21783
21784 if (!args) SWIG_fail;
21785 swig_obj[0] = args;
21786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21787 if (!SWIG_IsOK(res1)) {
21788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21789 }
21790 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21791 {
21792 PyThreadState* __tstate = wxPyBeginAllowThreads();
21793 delete arg1;
21794
21795 wxPyEndAllowThreads(__tstate);
21796 if (PyErr_Occurred()) SWIG_fail;
21797 }
21798 resultobj = SWIG_Py_Void();
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21806 PyObject *obj;
21807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21808 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21809 return SWIG_Py_Void();
21810 }
21811
21812 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21813 return SWIG_Python_InitShadowInstance(args);
21814 }
21815
21816 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21817 PyObject *resultobj = 0;
21818 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21819 wxString *arg2 = 0 ;
21820 wxConfigPathChanger *result = 0 ;
21821 void *argp1 = 0 ;
21822 int res1 = 0 ;
21823 bool temp2 = false ;
21824 PyObject * obj0 = 0 ;
21825 PyObject * obj1 = 0 ;
21826 char * kwnames[] = {
21827 (char *) "config",(char *) "entry", NULL
21828 };
21829
21830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21832 if (!SWIG_IsOK(res1)) {
21833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21834 }
21835 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21836 {
21837 arg2 = wxString_in_helper(obj1);
21838 if (arg2 == NULL) SWIG_fail;
21839 temp2 = true;
21840 }
21841 {
21842 PyThreadState* __tstate = wxPyBeginAllowThreads();
21843 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21844 wxPyEndAllowThreads(__tstate);
21845 if (PyErr_Occurred()) SWIG_fail;
21846 }
21847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21848 {
21849 if (temp2)
21850 delete arg2;
21851 }
21852 return resultobj;
21853 fail:
21854 {
21855 if (temp2)
21856 delete arg2;
21857 }
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21863 PyObject *resultobj = 0;
21864 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21865 void *argp1 = 0 ;
21866 int res1 = 0 ;
21867 PyObject *swig_obj[1] ;
21868
21869 if (!args) SWIG_fail;
21870 swig_obj[0] = args;
21871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21872 if (!SWIG_IsOK(res1)) {
21873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21874 }
21875 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21876 {
21877 PyThreadState* __tstate = wxPyBeginAllowThreads();
21878 delete arg1;
21879
21880 wxPyEndAllowThreads(__tstate);
21881 if (PyErr_Occurred()) SWIG_fail;
21882 }
21883 resultobj = SWIG_Py_Void();
21884 return resultobj;
21885 fail:
21886 return NULL;
21887 }
21888
21889
21890 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21891 PyObject *resultobj = 0;
21892 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21893 wxString *result = 0 ;
21894 void *argp1 = 0 ;
21895 int res1 = 0 ;
21896 PyObject *swig_obj[1] ;
21897
21898 if (!args) SWIG_fail;
21899 swig_obj[0] = args;
21900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21901 if (!SWIG_IsOK(res1)) {
21902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21903 }
21904 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21905 {
21906 PyThreadState* __tstate = wxPyBeginAllowThreads();
21907 {
21908 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21909 result = (wxString *) &_result_ref;
21910 }
21911 wxPyEndAllowThreads(__tstate);
21912 if (PyErr_Occurred()) SWIG_fail;
21913 }
21914 {
21915 #if wxUSE_UNICODE
21916 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21917 #else
21918 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21919 #endif
21920 }
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21928 PyObject *obj;
21929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21930 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21931 return SWIG_Py_Void();
21932 }
21933
21934 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21935 return SWIG_Python_InitShadowInstance(args);
21936 }
21937
21938 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21939 PyObject *resultobj = 0;
21940 wxString *arg1 = 0 ;
21941 wxString result;
21942 bool temp1 = false ;
21943 PyObject * obj0 = 0 ;
21944 char * kwnames[] = {
21945 (char *) "sz", NULL
21946 };
21947
21948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21949 {
21950 arg1 = wxString_in_helper(obj0);
21951 if (arg1 == NULL) SWIG_fail;
21952 temp1 = true;
21953 }
21954 {
21955 PyThreadState* __tstate = wxPyBeginAllowThreads();
21956 result = wxExpandEnvVars((wxString const &)*arg1);
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 {
21961 #if wxUSE_UNICODE
21962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21963 #else
21964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21965 #endif
21966 }
21967 {
21968 if (temp1)
21969 delete arg1;
21970 }
21971 return resultobj;
21972 fail:
21973 {
21974 if (temp1)
21975 delete arg1;
21976 }
21977 return NULL;
21978 }
21979
21980
21981 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21982 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21983 return 1;
21984 }
21985
21986
21987 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21988 PyObject *pyobj = 0;
21989
21990 {
21991 #if wxUSE_UNICODE
21992 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21993 #else
21994 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21995 #endif
21996 }
21997 return pyobj;
21998 }
21999
22000
22001 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22002 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22003 return 1;
22004 }
22005
22006
22007 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22008 PyObject *pyobj = 0;
22009
22010 {
22011 #if wxUSE_UNICODE
22012 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22013 #else
22014 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22015 #endif
22016 }
22017 return pyobj;
22018 }
22019
22020
22021 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22022 PyObject *resultobj = 0;
22023 wxDateTime::Country arg1 ;
22024 int val1 ;
22025 int ecode1 = 0 ;
22026 PyObject * obj0 = 0 ;
22027 char * kwnames[] = {
22028 (char *) "country", NULL
22029 };
22030
22031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22032 ecode1 = SWIG_AsVal_int(obj0, &val1);
22033 if (!SWIG_IsOK(ecode1)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22035 }
22036 arg1 = static_cast< wxDateTime::Country >(val1);
22037 {
22038 PyThreadState* __tstate = wxPyBeginAllowThreads();
22039 wxDateTime::SetCountry(arg1);
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 resultobj = SWIG_Py_Void();
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxDateTime::Country result;
22053
22054 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 result = (wxDateTime::Country)wxDateTime::GetCountry();
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 resultobj = SWIG_From_int(static_cast< int >(result));
22062 return resultobj;
22063 fail:
22064 return NULL;
22065 }
22066
22067
22068 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22069 PyObject *resultobj = 0;
22070 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22071 bool result;
22072 int val1 ;
22073 int ecode1 = 0 ;
22074 PyObject * obj0 = 0 ;
22075 char * kwnames[] = {
22076 (char *) "country", NULL
22077 };
22078
22079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22080 if (obj0) {
22081 ecode1 = SWIG_AsVal_int(obj0, &val1);
22082 if (!SWIG_IsOK(ecode1)) {
22083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22084 }
22085 arg1 = static_cast< wxDateTime::Country >(val1);
22086 }
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22090 wxPyEndAllowThreads(__tstate);
22091 if (PyErr_Occurred()) SWIG_fail;
22092 }
22093 {
22094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22095 }
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22103 PyObject *resultobj = 0;
22104 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22105 int result;
22106 int val1 ;
22107 int ecode1 = 0 ;
22108 PyObject * obj0 = 0 ;
22109 char * kwnames[] = {
22110 (char *) "cal", NULL
22111 };
22112
22113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
22114 if (obj0) {
22115 ecode1 = SWIG_AsVal_int(obj0, &val1);
22116 if (!SWIG_IsOK(ecode1)) {
22117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22118 }
22119 arg1 = static_cast< wxDateTime::Calendar >(val1);
22120 }
22121 {
22122 PyThreadState* __tstate = wxPyBeginAllowThreads();
22123 result = (int)wxDateTime::GetCurrentYear(arg1);
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 resultobj = SWIG_From_int(static_cast< int >(result));
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj = 0;
22136 int arg1 ;
22137 int result;
22138 int val1 ;
22139 int ecode1 = 0 ;
22140 PyObject * obj0 = 0 ;
22141 char * kwnames[] = {
22142 (char *) "year", NULL
22143 };
22144
22145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
22146 ecode1 = SWIG_AsVal_int(obj0, &val1);
22147 if (!SWIG_IsOK(ecode1)) {
22148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
22149 }
22150 arg1 = static_cast< int >(val1);
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (int)wxDateTime::ConvertYearToBC(arg1);
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 resultobj = SWIG_From_int(static_cast< int >(result));
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22165 PyObject *resultobj = 0;
22166 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22167 wxDateTime::Month result;
22168 int val1 ;
22169 int ecode1 = 0 ;
22170 PyObject * obj0 = 0 ;
22171 char * kwnames[] = {
22172 (char *) "cal", NULL
22173 };
22174
22175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22176 if (obj0) {
22177 ecode1 = SWIG_AsVal_int(obj0, &val1);
22178 if (!SWIG_IsOK(ecode1)) {
22179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22180 }
22181 arg1 = static_cast< wxDateTime::Calendar >(val1);
22182 }
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 resultobj = SWIG_From_int(static_cast< int >(result));
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22197 PyObject *resultobj = 0;
22198 int arg1 = (int) wxDateTime::Inv_Year ;
22199 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22200 bool result;
22201 int val1 ;
22202 int ecode1 = 0 ;
22203 int val2 ;
22204 int ecode2 = 0 ;
22205 PyObject * obj0 = 0 ;
22206 PyObject * obj1 = 0 ;
22207 char * kwnames[] = {
22208 (char *) "year",(char *) "cal", NULL
22209 };
22210
22211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22212 if (obj0) {
22213 ecode1 = SWIG_AsVal_int(obj0, &val1);
22214 if (!SWIG_IsOK(ecode1)) {
22215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22216 }
22217 arg1 = static_cast< int >(val1);
22218 }
22219 if (obj1) {
22220 ecode2 = SWIG_AsVal_int(obj1, &val2);
22221 if (!SWIG_IsOK(ecode2)) {
22222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22223 }
22224 arg2 = static_cast< wxDateTime::Calendar >(val2);
22225 }
22226 {
22227 PyThreadState* __tstate = wxPyBeginAllowThreads();
22228 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22229 wxPyEndAllowThreads(__tstate);
22230 if (PyErr_Occurred()) SWIG_fail;
22231 }
22232 {
22233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22234 }
22235 return resultobj;
22236 fail:
22237 return NULL;
22238 }
22239
22240
22241 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22242 PyObject *resultobj = 0;
22243 int arg1 = (int) wxDateTime::Inv_Year ;
22244 int result;
22245 int val1 ;
22246 int ecode1 = 0 ;
22247 PyObject * obj0 = 0 ;
22248 char * kwnames[] = {
22249 (char *) "year", NULL
22250 };
22251
22252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22253 if (obj0) {
22254 ecode1 = SWIG_AsVal_int(obj0, &val1);
22255 if (!SWIG_IsOK(ecode1)) {
22256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22257 }
22258 arg1 = static_cast< int >(val1);
22259 }
22260 {
22261 PyThreadState* __tstate = wxPyBeginAllowThreads();
22262 result = (int)wxDateTime::GetCentury(arg1);
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 resultobj = SWIG_From_int(static_cast< int >(result));
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22274 PyObject *resultobj = 0;
22275 int arg1 ;
22276 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22277 int result;
22278 int val1 ;
22279 int ecode1 = 0 ;
22280 int val2 ;
22281 int ecode2 = 0 ;
22282 PyObject * obj0 = 0 ;
22283 PyObject * obj1 = 0 ;
22284 char * kwnames[] = {
22285 (char *) "year",(char *) "cal", NULL
22286 };
22287
22288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22289 ecode1 = SWIG_AsVal_int(obj0, &val1);
22290 if (!SWIG_IsOK(ecode1)) {
22291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22292 }
22293 arg1 = static_cast< int >(val1);
22294 if (obj1) {
22295 ecode2 = SWIG_AsVal_int(obj1, &val2);
22296 if (!SWIG_IsOK(ecode2)) {
22297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22298 }
22299 arg2 = static_cast< wxDateTime::Calendar >(val2);
22300 }
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 resultobj = SWIG_From_int(static_cast< int >(result));
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22315 PyObject *resultobj = 0;
22316 wxDateTime::Month arg1 ;
22317 int arg2 = (int) wxDateTime::Inv_Year ;
22318 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22319 int result;
22320 int val1 ;
22321 int ecode1 = 0 ;
22322 int val2 ;
22323 int ecode2 = 0 ;
22324 int val3 ;
22325 int ecode3 = 0 ;
22326 PyObject * obj0 = 0 ;
22327 PyObject * obj1 = 0 ;
22328 PyObject * obj2 = 0 ;
22329 char * kwnames[] = {
22330 (char *) "month",(char *) "year",(char *) "cal", NULL
22331 };
22332
22333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22334 ecode1 = SWIG_AsVal_int(obj0, &val1);
22335 if (!SWIG_IsOK(ecode1)) {
22336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22337 }
22338 arg1 = static_cast< wxDateTime::Month >(val1);
22339 if (obj1) {
22340 ecode2 = SWIG_AsVal_int(obj1, &val2);
22341 if (!SWIG_IsOK(ecode2)) {
22342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22343 }
22344 arg2 = static_cast< int >(val2);
22345 }
22346 if (obj2) {
22347 ecode3 = SWIG_AsVal_int(obj2, &val3);
22348 if (!SWIG_IsOK(ecode3)) {
22349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22350 }
22351 arg3 = static_cast< wxDateTime::Calendar >(val3);
22352 }
22353 {
22354 PyThreadState* __tstate = wxPyBeginAllowThreads();
22355 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22356 wxPyEndAllowThreads(__tstate);
22357 if (PyErr_Occurred()) SWIG_fail;
22358 }
22359 resultobj = SWIG_From_int(static_cast< int >(result));
22360 return resultobj;
22361 fail:
22362 return NULL;
22363 }
22364
22365
22366 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22367 PyObject *resultobj = 0;
22368 wxDateTime::Month arg1 ;
22369 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22370 wxString result;
22371 int val1 ;
22372 int ecode1 = 0 ;
22373 int val2 ;
22374 int ecode2 = 0 ;
22375 PyObject * obj0 = 0 ;
22376 PyObject * obj1 = 0 ;
22377 char * kwnames[] = {
22378 (char *) "month",(char *) "flags", NULL
22379 };
22380
22381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22382 ecode1 = SWIG_AsVal_int(obj0, &val1);
22383 if (!SWIG_IsOK(ecode1)) {
22384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22385 }
22386 arg1 = static_cast< wxDateTime::Month >(val1);
22387 if (obj1) {
22388 ecode2 = SWIG_AsVal_int(obj1, &val2);
22389 if (!SWIG_IsOK(ecode2)) {
22390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22391 }
22392 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22393 }
22394 {
22395 PyThreadState* __tstate = wxPyBeginAllowThreads();
22396 result = wxDateTime::GetMonthName(arg1,arg2);
22397 wxPyEndAllowThreads(__tstate);
22398 if (PyErr_Occurred()) SWIG_fail;
22399 }
22400 {
22401 #if wxUSE_UNICODE
22402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22403 #else
22404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22405 #endif
22406 }
22407 return resultobj;
22408 fail:
22409 return NULL;
22410 }
22411
22412
22413 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22414 PyObject *resultobj = 0;
22415 wxDateTime::WeekDay arg1 ;
22416 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22417 wxString result;
22418 int val1 ;
22419 int ecode1 = 0 ;
22420 int val2 ;
22421 int ecode2 = 0 ;
22422 PyObject * obj0 = 0 ;
22423 PyObject * obj1 = 0 ;
22424 char * kwnames[] = {
22425 (char *) "weekday",(char *) "flags", NULL
22426 };
22427
22428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22429 ecode1 = SWIG_AsVal_int(obj0, &val1);
22430 if (!SWIG_IsOK(ecode1)) {
22431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22432 }
22433 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22434 if (obj1) {
22435 ecode2 = SWIG_AsVal_int(obj1, &val2);
22436 if (!SWIG_IsOK(ecode2)) {
22437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22438 }
22439 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22440 }
22441 {
22442 PyThreadState* __tstate = wxPyBeginAllowThreads();
22443 result = wxDateTime::GetWeekDayName(arg1,arg2);
22444 wxPyEndAllowThreads(__tstate);
22445 if (PyErr_Occurred()) SWIG_fail;
22446 }
22447 {
22448 #if wxUSE_UNICODE
22449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22450 #else
22451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22452 #endif
22453 }
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 PyObject *result = 0 ;
22463
22464 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22465 {
22466 PyThreadState* __tstate = wxPyBeginAllowThreads();
22467 result = (PyObject *)wxDateTime_GetAmPmStrings();
22468 wxPyEndAllowThreads(__tstate);
22469 if (PyErr_Occurred()) SWIG_fail;
22470 }
22471 resultobj = result;
22472 return resultobj;
22473 fail:
22474 return NULL;
22475 }
22476
22477
22478 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22479 PyObject *resultobj = 0;
22480 int arg1 = (int) wxDateTime::Inv_Year ;
22481 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22482 bool result;
22483 int val1 ;
22484 int ecode1 = 0 ;
22485 int val2 ;
22486 int ecode2 = 0 ;
22487 PyObject * obj0 = 0 ;
22488 PyObject * obj1 = 0 ;
22489 char * kwnames[] = {
22490 (char *) "year",(char *) "country", NULL
22491 };
22492
22493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22494 if (obj0) {
22495 ecode1 = SWIG_AsVal_int(obj0, &val1);
22496 if (!SWIG_IsOK(ecode1)) {
22497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22498 }
22499 arg1 = static_cast< int >(val1);
22500 }
22501 if (obj1) {
22502 ecode2 = SWIG_AsVal_int(obj1, &val2);
22503 if (!SWIG_IsOK(ecode2)) {
22504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22505 }
22506 arg2 = static_cast< wxDateTime::Country >(val2);
22507 }
22508 {
22509 PyThreadState* __tstate = wxPyBeginAllowThreads();
22510 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22511 wxPyEndAllowThreads(__tstate);
22512 if (PyErr_Occurred()) SWIG_fail;
22513 }
22514 {
22515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22516 }
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj = 0;
22525 int arg1 = (int) wxDateTime::Inv_Year ;
22526 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22527 wxDateTime result;
22528 int val1 ;
22529 int ecode1 = 0 ;
22530 int val2 ;
22531 int ecode2 = 0 ;
22532 PyObject * obj0 = 0 ;
22533 PyObject * obj1 = 0 ;
22534 char * kwnames[] = {
22535 (char *) "year",(char *) "country", NULL
22536 };
22537
22538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22539 if (obj0) {
22540 ecode1 = SWIG_AsVal_int(obj0, &val1);
22541 if (!SWIG_IsOK(ecode1)) {
22542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22543 }
22544 arg1 = static_cast< int >(val1);
22545 }
22546 if (obj1) {
22547 ecode2 = SWIG_AsVal_int(obj1, &val2);
22548 if (!SWIG_IsOK(ecode2)) {
22549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22550 }
22551 arg2 = static_cast< wxDateTime::Country >(val2);
22552 }
22553 {
22554 PyThreadState* __tstate = wxPyBeginAllowThreads();
22555 result = wxDateTime::GetBeginDST(arg1,arg2);
22556 wxPyEndAllowThreads(__tstate);
22557 if (PyErr_Occurred()) SWIG_fail;
22558 }
22559 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22560 return resultobj;
22561 fail:
22562 return NULL;
22563 }
22564
22565
22566 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22567 PyObject *resultobj = 0;
22568 int arg1 = (int) wxDateTime::Inv_Year ;
22569 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22570 wxDateTime result;
22571 int val1 ;
22572 int ecode1 = 0 ;
22573 int val2 ;
22574 int ecode2 = 0 ;
22575 PyObject * obj0 = 0 ;
22576 PyObject * obj1 = 0 ;
22577 char * kwnames[] = {
22578 (char *) "year",(char *) "country", NULL
22579 };
22580
22581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22582 if (obj0) {
22583 ecode1 = SWIG_AsVal_int(obj0, &val1);
22584 if (!SWIG_IsOK(ecode1)) {
22585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22586 }
22587 arg1 = static_cast< int >(val1);
22588 }
22589 if (obj1) {
22590 ecode2 = SWIG_AsVal_int(obj1, &val2);
22591 if (!SWIG_IsOK(ecode2)) {
22592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22593 }
22594 arg2 = static_cast< wxDateTime::Country >(val2);
22595 }
22596 {
22597 PyThreadState* __tstate = wxPyBeginAllowThreads();
22598 result = wxDateTime::GetEndDST(arg1,arg2);
22599 wxPyEndAllowThreads(__tstate);
22600 if (PyErr_Occurred()) SWIG_fail;
22601 }
22602 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22603 return resultobj;
22604 fail:
22605 return NULL;
22606 }
22607
22608
22609 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22610 PyObject *resultobj = 0;
22611 wxDateTime result;
22612
22613 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22614 {
22615 PyThreadState* __tstate = wxPyBeginAllowThreads();
22616 result = wxDateTime::Now();
22617 wxPyEndAllowThreads(__tstate);
22618 if (PyErr_Occurred()) SWIG_fail;
22619 }
22620 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22621 return resultobj;
22622 fail:
22623 return NULL;
22624 }
22625
22626
22627 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22628 PyObject *resultobj = 0;
22629 wxDateTime result;
22630
22631 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22632 {
22633 PyThreadState* __tstate = wxPyBeginAllowThreads();
22634 result = wxDateTime::UNow();
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22639 return resultobj;
22640 fail:
22641 return NULL;
22642 }
22643
22644
22645 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22646 PyObject *resultobj = 0;
22647 wxDateTime result;
22648
22649 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22650 {
22651 PyThreadState* __tstate = wxPyBeginAllowThreads();
22652 result = wxDateTime::Today();
22653 wxPyEndAllowThreads(__tstate);
22654 if (PyErr_Occurred()) SWIG_fail;
22655 }
22656 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22657 return resultobj;
22658 fail:
22659 return NULL;
22660 }
22661
22662
22663 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22664 PyObject *resultobj = 0;
22665 wxDateTime *result = 0 ;
22666
22667 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22668 {
22669 PyThreadState* __tstate = wxPyBeginAllowThreads();
22670 result = (wxDateTime *)new wxDateTime();
22671 wxPyEndAllowThreads(__tstate);
22672 if (PyErr_Occurred()) SWIG_fail;
22673 }
22674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22675 return resultobj;
22676 fail:
22677 return NULL;
22678 }
22679
22680
22681 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22682 PyObject *resultobj = 0;
22683 time_t arg1 ;
22684 wxDateTime *result = 0 ;
22685 unsigned int val1 ;
22686 int ecode1 = 0 ;
22687 PyObject * obj0 = 0 ;
22688 char * kwnames[] = {
22689 (char *) "timet", NULL
22690 };
22691
22692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22693 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22694 if (!SWIG_IsOK(ecode1)) {
22695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22696 }
22697 arg1 = static_cast< time_t >(val1);
22698 {
22699 PyThreadState* __tstate = wxPyBeginAllowThreads();
22700 result = (wxDateTime *)new wxDateTime(arg1);
22701 wxPyEndAllowThreads(__tstate);
22702 if (PyErr_Occurred()) SWIG_fail;
22703 }
22704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22705 return resultobj;
22706 fail:
22707 return NULL;
22708 }
22709
22710
22711 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22712 PyObject *resultobj = 0;
22713 double arg1 ;
22714 wxDateTime *result = 0 ;
22715 double val1 ;
22716 int ecode1 = 0 ;
22717 PyObject * obj0 = 0 ;
22718 char * kwnames[] = {
22719 (char *) "jdn", NULL
22720 };
22721
22722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22723 ecode1 = SWIG_AsVal_double(obj0, &val1);
22724 if (!SWIG_IsOK(ecode1)) {
22725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22726 }
22727 arg1 = static_cast< double >(val1);
22728 {
22729 PyThreadState* __tstate = wxPyBeginAllowThreads();
22730 result = (wxDateTime *)new wxDateTime(arg1);
22731 wxPyEndAllowThreads(__tstate);
22732 if (PyErr_Occurred()) SWIG_fail;
22733 }
22734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22735 return resultobj;
22736 fail:
22737 return NULL;
22738 }
22739
22740
22741 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22742 PyObject *resultobj = 0;
22743 int arg1 ;
22744 int arg2 = (int) 0 ;
22745 int arg3 = (int) 0 ;
22746 int arg4 = (int) 0 ;
22747 wxDateTime *result = 0 ;
22748 int val1 ;
22749 int ecode1 = 0 ;
22750 int val2 ;
22751 int ecode2 = 0 ;
22752 int val3 ;
22753 int ecode3 = 0 ;
22754 int val4 ;
22755 int ecode4 = 0 ;
22756 PyObject * obj0 = 0 ;
22757 PyObject * obj1 = 0 ;
22758 PyObject * obj2 = 0 ;
22759 PyObject * obj3 = 0 ;
22760 char * kwnames[] = {
22761 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22762 };
22763
22764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22765 ecode1 = SWIG_AsVal_int(obj0, &val1);
22766 if (!SWIG_IsOK(ecode1)) {
22767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22768 }
22769 arg1 = static_cast< int >(val1);
22770 if (obj1) {
22771 ecode2 = SWIG_AsVal_int(obj1, &val2);
22772 if (!SWIG_IsOK(ecode2)) {
22773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22774 }
22775 arg2 = static_cast< int >(val2);
22776 }
22777 if (obj2) {
22778 ecode3 = SWIG_AsVal_int(obj2, &val3);
22779 if (!SWIG_IsOK(ecode3)) {
22780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22781 }
22782 arg3 = static_cast< int >(val3);
22783 }
22784 if (obj3) {
22785 ecode4 = SWIG_AsVal_int(obj3, &val4);
22786 if (!SWIG_IsOK(ecode4)) {
22787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22788 }
22789 arg4 = static_cast< int >(val4);
22790 }
22791 {
22792 PyThreadState* __tstate = wxPyBeginAllowThreads();
22793 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22794 wxPyEndAllowThreads(__tstate);
22795 if (PyErr_Occurred()) SWIG_fail;
22796 }
22797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22798 return resultobj;
22799 fail:
22800 return NULL;
22801 }
22802
22803
22804 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22805 PyObject *resultobj = 0;
22806 int arg1 ;
22807 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22808 int arg3 = (int) wxDateTime::Inv_Year ;
22809 int arg4 = (int) 0 ;
22810 int arg5 = (int) 0 ;
22811 int arg6 = (int) 0 ;
22812 int arg7 = (int) 0 ;
22813 wxDateTime *result = 0 ;
22814 int val1 ;
22815 int ecode1 = 0 ;
22816 int val2 ;
22817 int ecode2 = 0 ;
22818 int val3 ;
22819 int ecode3 = 0 ;
22820 int val4 ;
22821 int ecode4 = 0 ;
22822 int val5 ;
22823 int ecode5 = 0 ;
22824 int val6 ;
22825 int ecode6 = 0 ;
22826 int val7 ;
22827 int ecode7 = 0 ;
22828 PyObject * obj0 = 0 ;
22829 PyObject * obj1 = 0 ;
22830 PyObject * obj2 = 0 ;
22831 PyObject * obj3 = 0 ;
22832 PyObject * obj4 = 0 ;
22833 PyObject * obj5 = 0 ;
22834 PyObject * obj6 = 0 ;
22835 char * kwnames[] = {
22836 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22837 };
22838
22839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22840 ecode1 = SWIG_AsVal_int(obj0, &val1);
22841 if (!SWIG_IsOK(ecode1)) {
22842 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22843 }
22844 arg1 = static_cast< int >(val1);
22845 if (obj1) {
22846 ecode2 = SWIG_AsVal_int(obj1, &val2);
22847 if (!SWIG_IsOK(ecode2)) {
22848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22849 }
22850 arg2 = static_cast< wxDateTime::Month >(val2);
22851 }
22852 if (obj2) {
22853 ecode3 = SWIG_AsVal_int(obj2, &val3);
22854 if (!SWIG_IsOK(ecode3)) {
22855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22856 }
22857 arg3 = static_cast< int >(val3);
22858 }
22859 if (obj3) {
22860 ecode4 = SWIG_AsVal_int(obj3, &val4);
22861 if (!SWIG_IsOK(ecode4)) {
22862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22863 }
22864 arg4 = static_cast< int >(val4);
22865 }
22866 if (obj4) {
22867 ecode5 = SWIG_AsVal_int(obj4, &val5);
22868 if (!SWIG_IsOK(ecode5)) {
22869 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22870 }
22871 arg5 = static_cast< int >(val5);
22872 }
22873 if (obj5) {
22874 ecode6 = SWIG_AsVal_int(obj5, &val6);
22875 if (!SWIG_IsOK(ecode6)) {
22876 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22877 }
22878 arg6 = static_cast< int >(val6);
22879 }
22880 if (obj6) {
22881 ecode7 = SWIG_AsVal_int(obj6, &val7);
22882 if (!SWIG_IsOK(ecode7)) {
22883 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22884 }
22885 arg7 = static_cast< int >(val7);
22886 }
22887 {
22888 PyThreadState* __tstate = wxPyBeginAllowThreads();
22889 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22890 wxPyEndAllowThreads(__tstate);
22891 if (PyErr_Occurred()) SWIG_fail;
22892 }
22893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22894 return resultobj;
22895 fail:
22896 return NULL;
22897 }
22898
22899
22900 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22901 PyObject *resultobj = 0;
22902 wxDateTime *arg1 = 0 ;
22903 wxDateTime *result = 0 ;
22904 void *argp1 = 0 ;
22905 int res1 = 0 ;
22906 PyObject * obj0 = 0 ;
22907 char * kwnames[] = {
22908 (char *) "date", NULL
22909 };
22910
22911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22912 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22913 if (!SWIG_IsOK(res1)) {
22914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22915 }
22916 if (!argp1) {
22917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22918 }
22919 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22920 {
22921 PyThreadState* __tstate = wxPyBeginAllowThreads();
22922 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22923 wxPyEndAllowThreads(__tstate);
22924 if (PyErr_Occurred()) SWIG_fail;
22925 }
22926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22927 return resultobj;
22928 fail:
22929 return NULL;
22930 }
22931
22932
22933 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22934 PyObject *resultobj = 0;
22935 wxDateTime *arg1 = (wxDateTime *) 0 ;
22936 void *argp1 = 0 ;
22937 int res1 = 0 ;
22938 PyObject *swig_obj[1] ;
22939
22940 if (!args) SWIG_fail;
22941 swig_obj[0] = args;
22942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22943 if (!SWIG_IsOK(res1)) {
22944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22945 }
22946 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 delete arg1;
22950
22951 wxPyEndAllowThreads(__tstate);
22952 if (PyErr_Occurred()) SWIG_fail;
22953 }
22954 resultobj = SWIG_Py_Void();
22955 return resultobj;
22956 fail:
22957 return NULL;
22958 }
22959
22960
22961 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22962 PyObject *resultobj = 0;
22963 wxDateTime *arg1 = (wxDateTime *) 0 ;
22964 wxDateTime *result = 0 ;
22965 void *argp1 = 0 ;
22966 int res1 = 0 ;
22967 PyObject *swig_obj[1] ;
22968
22969 if (!args) SWIG_fail;
22970 swig_obj[0] = args;
22971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22972 if (!SWIG_IsOK(res1)) {
22973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22974 }
22975 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22976 {
22977 PyThreadState* __tstate = wxPyBeginAllowThreads();
22978 {
22979 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22980 result = (wxDateTime *) &_result_ref;
22981 }
22982 wxPyEndAllowThreads(__tstate);
22983 if (PyErr_Occurred()) SWIG_fail;
22984 }
22985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22986 return resultobj;
22987 fail:
22988 return NULL;
22989 }
22990
22991
22992 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22993 PyObject *resultobj = 0;
22994 wxDateTime *arg1 = (wxDateTime *) 0 ;
22995 time_t arg2 ;
22996 wxDateTime *result = 0 ;
22997 void *argp1 = 0 ;
22998 int res1 = 0 ;
22999 unsigned int val2 ;
23000 int ecode2 = 0 ;
23001 PyObject * obj0 = 0 ;
23002 PyObject * obj1 = 0 ;
23003 char * kwnames[] = {
23004 (char *) "self",(char *) "timet", NULL
23005 };
23006
23007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23009 if (!SWIG_IsOK(res1)) {
23010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23011 }
23012 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23013 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23014 if (!SWIG_IsOK(ecode2)) {
23015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23016 }
23017 arg2 = static_cast< time_t >(val2);
23018 {
23019 PyThreadState* __tstate = wxPyBeginAllowThreads();
23020 {
23021 wxDateTime &_result_ref = (arg1)->Set(arg2);
23022 result = (wxDateTime *) &_result_ref;
23023 }
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23035 PyObject *resultobj = 0;
23036 wxDateTime *arg1 = (wxDateTime *) 0 ;
23037 double arg2 ;
23038 wxDateTime *result = 0 ;
23039 void *argp1 = 0 ;
23040 int res1 = 0 ;
23041 double val2 ;
23042 int ecode2 = 0 ;
23043 PyObject * obj0 = 0 ;
23044 PyObject * obj1 = 0 ;
23045 char * kwnames[] = {
23046 (char *) "self",(char *) "jdn", NULL
23047 };
23048
23049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23051 if (!SWIG_IsOK(res1)) {
23052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23053 }
23054 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23055 ecode2 = SWIG_AsVal_double(obj1, &val2);
23056 if (!SWIG_IsOK(ecode2)) {
23057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23058 }
23059 arg2 = static_cast< double >(val2);
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 {
23063 wxDateTime &_result_ref = (arg1)->Set(arg2);
23064 result = (wxDateTime *) &_result_ref;
23065 }
23066 wxPyEndAllowThreads(__tstate);
23067 if (PyErr_Occurred()) SWIG_fail;
23068 }
23069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23077 PyObject *resultobj = 0;
23078 wxDateTime *arg1 = (wxDateTime *) 0 ;
23079 int arg2 ;
23080 int arg3 = (int) 0 ;
23081 int arg4 = (int) 0 ;
23082 int arg5 = (int) 0 ;
23083 wxDateTime *result = 0 ;
23084 void *argp1 = 0 ;
23085 int res1 = 0 ;
23086 int val2 ;
23087 int ecode2 = 0 ;
23088 int val3 ;
23089 int ecode3 = 0 ;
23090 int val4 ;
23091 int ecode4 = 0 ;
23092 int val5 ;
23093 int ecode5 = 0 ;
23094 PyObject * obj0 = 0 ;
23095 PyObject * obj1 = 0 ;
23096 PyObject * obj2 = 0 ;
23097 PyObject * obj3 = 0 ;
23098 PyObject * obj4 = 0 ;
23099 char * kwnames[] = {
23100 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23101 };
23102
23103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
23107 }
23108 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23109 ecode2 = SWIG_AsVal_int(obj1, &val2);
23110 if (!SWIG_IsOK(ecode2)) {
23111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
23112 }
23113 arg2 = static_cast< int >(val2);
23114 if (obj2) {
23115 ecode3 = SWIG_AsVal_int(obj2, &val3);
23116 if (!SWIG_IsOK(ecode3)) {
23117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
23118 }
23119 arg3 = static_cast< int >(val3);
23120 }
23121 if (obj3) {
23122 ecode4 = SWIG_AsVal_int(obj3, &val4);
23123 if (!SWIG_IsOK(ecode4)) {
23124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
23125 }
23126 arg4 = static_cast< int >(val4);
23127 }
23128 if (obj4) {
23129 ecode5 = SWIG_AsVal_int(obj4, &val5);
23130 if (!SWIG_IsOK(ecode5)) {
23131 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
23132 }
23133 arg5 = static_cast< int >(val5);
23134 }
23135 {
23136 PyThreadState* __tstate = wxPyBeginAllowThreads();
23137 {
23138 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
23139 result = (wxDateTime *) &_result_ref;
23140 }
23141 wxPyEndAllowThreads(__tstate);
23142 if (PyErr_Occurred()) SWIG_fail;
23143 }
23144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23145 return resultobj;
23146 fail:
23147 return NULL;
23148 }
23149
23150
23151 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23152 PyObject *resultobj = 0;
23153 wxDateTime *arg1 = (wxDateTime *) 0 ;
23154 int arg2 ;
23155 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23156 int arg4 = (int) wxDateTime::Inv_Year ;
23157 int arg5 = (int) 0 ;
23158 int arg6 = (int) 0 ;
23159 int arg7 = (int) 0 ;
23160 int arg8 = (int) 0 ;
23161 wxDateTime *result = 0 ;
23162 void *argp1 = 0 ;
23163 int res1 = 0 ;
23164 int val2 ;
23165 int ecode2 = 0 ;
23166 int val3 ;
23167 int ecode3 = 0 ;
23168 int val4 ;
23169 int ecode4 = 0 ;
23170 int val5 ;
23171 int ecode5 = 0 ;
23172 int val6 ;
23173 int ecode6 = 0 ;
23174 int val7 ;
23175 int ecode7 = 0 ;
23176 int val8 ;
23177 int ecode8 = 0 ;
23178 PyObject * obj0 = 0 ;
23179 PyObject * obj1 = 0 ;
23180 PyObject * obj2 = 0 ;
23181 PyObject * obj3 = 0 ;
23182 PyObject * obj4 = 0 ;
23183 PyObject * obj5 = 0 ;
23184 PyObject * obj6 = 0 ;
23185 PyObject * obj7 = 0 ;
23186 char * kwnames[] = {
23187 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23188 };
23189
23190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23192 if (!SWIG_IsOK(res1)) {
23193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23194 }
23195 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23196 ecode2 = SWIG_AsVal_int(obj1, &val2);
23197 if (!SWIG_IsOK(ecode2)) {
23198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23199 }
23200 arg2 = static_cast< int >(val2);
23201 if (obj2) {
23202 ecode3 = SWIG_AsVal_int(obj2, &val3);
23203 if (!SWIG_IsOK(ecode3)) {
23204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23205 }
23206 arg3 = static_cast< wxDateTime::Month >(val3);
23207 }
23208 if (obj3) {
23209 ecode4 = SWIG_AsVal_int(obj3, &val4);
23210 if (!SWIG_IsOK(ecode4)) {
23211 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23212 }
23213 arg4 = static_cast< int >(val4);
23214 }
23215 if (obj4) {
23216 ecode5 = SWIG_AsVal_int(obj4, &val5);
23217 if (!SWIG_IsOK(ecode5)) {
23218 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23219 }
23220 arg5 = static_cast< int >(val5);
23221 }
23222 if (obj5) {
23223 ecode6 = SWIG_AsVal_int(obj5, &val6);
23224 if (!SWIG_IsOK(ecode6)) {
23225 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23226 }
23227 arg6 = static_cast< int >(val6);
23228 }
23229 if (obj6) {
23230 ecode7 = SWIG_AsVal_int(obj6, &val7);
23231 if (!SWIG_IsOK(ecode7)) {
23232 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23233 }
23234 arg7 = static_cast< int >(val7);
23235 }
23236 if (obj7) {
23237 ecode8 = SWIG_AsVal_int(obj7, &val8);
23238 if (!SWIG_IsOK(ecode8)) {
23239 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23240 }
23241 arg8 = static_cast< int >(val8);
23242 }
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 {
23246 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23247 result = (wxDateTime *) &_result_ref;
23248 }
23249 wxPyEndAllowThreads(__tstate);
23250 if (PyErr_Occurred()) SWIG_fail;
23251 }
23252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23253 return resultobj;
23254 fail:
23255 return NULL;
23256 }
23257
23258
23259 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23260 PyObject *resultobj = 0;
23261 wxDateTime *arg1 = (wxDateTime *) 0 ;
23262 wxDateTime *result = 0 ;
23263 void *argp1 = 0 ;
23264 int res1 = 0 ;
23265 PyObject *swig_obj[1] ;
23266
23267 if (!args) SWIG_fail;
23268 swig_obj[0] = args;
23269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23270 if (!SWIG_IsOK(res1)) {
23271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23272 }
23273 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23274 {
23275 PyThreadState* __tstate = wxPyBeginAllowThreads();
23276 {
23277 wxDateTime &_result_ref = (arg1)->ResetTime();
23278 result = (wxDateTime *) &_result_ref;
23279 }
23280 wxPyEndAllowThreads(__tstate);
23281 if (PyErr_Occurred()) SWIG_fail;
23282 }
23283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23284 return resultobj;
23285 fail:
23286 return NULL;
23287 }
23288
23289
23290 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23291 PyObject *resultobj = 0;
23292 wxDateTime *arg1 = (wxDateTime *) 0 ;
23293 int arg2 ;
23294 wxDateTime *result = 0 ;
23295 void *argp1 = 0 ;
23296 int res1 = 0 ;
23297 int val2 ;
23298 int ecode2 = 0 ;
23299 PyObject * obj0 = 0 ;
23300 PyObject * obj1 = 0 ;
23301 char * kwnames[] = {
23302 (char *) "self",(char *) "year", NULL
23303 };
23304
23305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23307 if (!SWIG_IsOK(res1)) {
23308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23309 }
23310 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23311 ecode2 = SWIG_AsVal_int(obj1, &val2);
23312 if (!SWIG_IsOK(ecode2)) {
23313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23314 }
23315 arg2 = static_cast< int >(val2);
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 {
23319 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23320 result = (wxDateTime *) &_result_ref;
23321 }
23322 wxPyEndAllowThreads(__tstate);
23323 if (PyErr_Occurred()) SWIG_fail;
23324 }
23325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23326 return resultobj;
23327 fail:
23328 return NULL;
23329 }
23330
23331
23332 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23333 PyObject *resultobj = 0;
23334 wxDateTime *arg1 = (wxDateTime *) 0 ;
23335 wxDateTime::Month arg2 ;
23336 wxDateTime *result = 0 ;
23337 void *argp1 = 0 ;
23338 int res1 = 0 ;
23339 int val2 ;
23340 int ecode2 = 0 ;
23341 PyObject * obj0 = 0 ;
23342 PyObject * obj1 = 0 ;
23343 char * kwnames[] = {
23344 (char *) "self",(char *) "month", NULL
23345 };
23346
23347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23349 if (!SWIG_IsOK(res1)) {
23350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23351 }
23352 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23353 ecode2 = SWIG_AsVal_int(obj1, &val2);
23354 if (!SWIG_IsOK(ecode2)) {
23355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23356 }
23357 arg2 = static_cast< wxDateTime::Month >(val2);
23358 {
23359 PyThreadState* __tstate = wxPyBeginAllowThreads();
23360 {
23361 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23362 result = (wxDateTime *) &_result_ref;
23363 }
23364 wxPyEndAllowThreads(__tstate);
23365 if (PyErr_Occurred()) SWIG_fail;
23366 }
23367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23368 return resultobj;
23369 fail:
23370 return NULL;
23371 }
23372
23373
23374 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23375 PyObject *resultobj = 0;
23376 wxDateTime *arg1 = (wxDateTime *) 0 ;
23377 int arg2 ;
23378 wxDateTime *result = 0 ;
23379 void *argp1 = 0 ;
23380 int res1 = 0 ;
23381 int val2 ;
23382 int ecode2 = 0 ;
23383 PyObject * obj0 = 0 ;
23384 PyObject * obj1 = 0 ;
23385 char * kwnames[] = {
23386 (char *) "self",(char *) "day", NULL
23387 };
23388
23389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23391 if (!SWIG_IsOK(res1)) {
23392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23393 }
23394 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23395 ecode2 = SWIG_AsVal_int(obj1, &val2);
23396 if (!SWIG_IsOK(ecode2)) {
23397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23398 }
23399 arg2 = static_cast< int >(val2);
23400 {
23401 PyThreadState* __tstate = wxPyBeginAllowThreads();
23402 {
23403 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23404 result = (wxDateTime *) &_result_ref;
23405 }
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23410 return resultobj;
23411 fail:
23412 return NULL;
23413 }
23414
23415
23416 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23417 PyObject *resultobj = 0;
23418 wxDateTime *arg1 = (wxDateTime *) 0 ;
23419 int arg2 ;
23420 wxDateTime *result = 0 ;
23421 void *argp1 = 0 ;
23422 int res1 = 0 ;
23423 int val2 ;
23424 int ecode2 = 0 ;
23425 PyObject * obj0 = 0 ;
23426 PyObject * obj1 = 0 ;
23427 char * kwnames[] = {
23428 (char *) "self",(char *) "hour", NULL
23429 };
23430
23431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23433 if (!SWIG_IsOK(res1)) {
23434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23435 }
23436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23437 ecode2 = SWIG_AsVal_int(obj1, &val2);
23438 if (!SWIG_IsOK(ecode2)) {
23439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23440 }
23441 arg2 = static_cast< int >(val2);
23442 {
23443 PyThreadState* __tstate = wxPyBeginAllowThreads();
23444 {
23445 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23446 result = (wxDateTime *) &_result_ref;
23447 }
23448 wxPyEndAllowThreads(__tstate);
23449 if (PyErr_Occurred()) SWIG_fail;
23450 }
23451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23452 return resultobj;
23453 fail:
23454 return NULL;
23455 }
23456
23457
23458 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23459 PyObject *resultobj = 0;
23460 wxDateTime *arg1 = (wxDateTime *) 0 ;
23461 int arg2 ;
23462 wxDateTime *result = 0 ;
23463 void *argp1 = 0 ;
23464 int res1 = 0 ;
23465 int val2 ;
23466 int ecode2 = 0 ;
23467 PyObject * obj0 = 0 ;
23468 PyObject * obj1 = 0 ;
23469 char * kwnames[] = {
23470 (char *) "self",(char *) "minute", NULL
23471 };
23472
23473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23475 if (!SWIG_IsOK(res1)) {
23476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23477 }
23478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23479 ecode2 = SWIG_AsVal_int(obj1, &val2);
23480 if (!SWIG_IsOK(ecode2)) {
23481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23482 }
23483 arg2 = static_cast< int >(val2);
23484 {
23485 PyThreadState* __tstate = wxPyBeginAllowThreads();
23486 {
23487 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23488 result = (wxDateTime *) &_result_ref;
23489 }
23490 wxPyEndAllowThreads(__tstate);
23491 if (PyErr_Occurred()) SWIG_fail;
23492 }
23493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23494 return resultobj;
23495 fail:
23496 return NULL;
23497 }
23498
23499
23500 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23501 PyObject *resultobj = 0;
23502 wxDateTime *arg1 = (wxDateTime *) 0 ;
23503 int arg2 ;
23504 wxDateTime *result = 0 ;
23505 void *argp1 = 0 ;
23506 int res1 = 0 ;
23507 int val2 ;
23508 int ecode2 = 0 ;
23509 PyObject * obj0 = 0 ;
23510 PyObject * obj1 = 0 ;
23511 char * kwnames[] = {
23512 (char *) "self",(char *) "second", NULL
23513 };
23514
23515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23517 if (!SWIG_IsOK(res1)) {
23518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23519 }
23520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23521 ecode2 = SWIG_AsVal_int(obj1, &val2);
23522 if (!SWIG_IsOK(ecode2)) {
23523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23524 }
23525 arg2 = static_cast< int >(val2);
23526 {
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 {
23529 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23530 result = (wxDateTime *) &_result_ref;
23531 }
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23536 return resultobj;
23537 fail:
23538 return NULL;
23539 }
23540
23541
23542 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23543 PyObject *resultobj = 0;
23544 wxDateTime *arg1 = (wxDateTime *) 0 ;
23545 int arg2 ;
23546 wxDateTime *result = 0 ;
23547 void *argp1 = 0 ;
23548 int res1 = 0 ;
23549 int val2 ;
23550 int ecode2 = 0 ;
23551 PyObject * obj0 = 0 ;
23552 PyObject * obj1 = 0 ;
23553 char * kwnames[] = {
23554 (char *) "self",(char *) "millisecond", NULL
23555 };
23556
23557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23559 if (!SWIG_IsOK(res1)) {
23560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23561 }
23562 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23563 ecode2 = SWIG_AsVal_int(obj1, &val2);
23564 if (!SWIG_IsOK(ecode2)) {
23565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23566 }
23567 arg2 = static_cast< int >(val2);
23568 {
23569 PyThreadState* __tstate = wxPyBeginAllowThreads();
23570 {
23571 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23572 result = (wxDateTime *) &_result_ref;
23573 }
23574 wxPyEndAllowThreads(__tstate);
23575 if (PyErr_Occurred()) SWIG_fail;
23576 }
23577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23578 return resultobj;
23579 fail:
23580 return NULL;
23581 }
23582
23583
23584 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23585 PyObject *resultobj = 0;
23586 wxDateTime *arg1 = (wxDateTime *) 0 ;
23587 wxDateTime::WeekDay arg2 ;
23588 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23589 wxDateTime *result = 0 ;
23590 void *argp1 = 0 ;
23591 int res1 = 0 ;
23592 int val2 ;
23593 int ecode2 = 0 ;
23594 int val3 ;
23595 int ecode3 = 0 ;
23596 PyObject * obj0 = 0 ;
23597 PyObject * obj1 = 0 ;
23598 PyObject * obj2 = 0 ;
23599 char * kwnames[] = {
23600 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23601 };
23602
23603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23605 if (!SWIG_IsOK(res1)) {
23606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23607 }
23608 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23609 ecode2 = SWIG_AsVal_int(obj1, &val2);
23610 if (!SWIG_IsOK(ecode2)) {
23611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23612 }
23613 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23614 if (obj2) {
23615 ecode3 = SWIG_AsVal_int(obj2, &val3);
23616 if (!SWIG_IsOK(ecode3)) {
23617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23618 }
23619 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23620 }
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 {
23624 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23625 result = (wxDateTime *) &_result_ref;
23626 }
23627 wxPyEndAllowThreads(__tstate);
23628 if (PyErr_Occurred()) SWIG_fail;
23629 }
23630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23638 PyObject *resultobj = 0;
23639 wxDateTime *arg1 = (wxDateTime *) 0 ;
23640 wxDateTime::WeekDay arg2 ;
23641 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23642 wxDateTime result;
23643 void *argp1 = 0 ;
23644 int res1 = 0 ;
23645 int val2 ;
23646 int ecode2 = 0 ;
23647 int val3 ;
23648 int ecode3 = 0 ;
23649 PyObject * obj0 = 0 ;
23650 PyObject * obj1 = 0 ;
23651 PyObject * obj2 = 0 ;
23652 char * kwnames[] = {
23653 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23654 };
23655
23656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23658 if (!SWIG_IsOK(res1)) {
23659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23660 }
23661 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23662 ecode2 = SWIG_AsVal_int(obj1, &val2);
23663 if (!SWIG_IsOK(ecode2)) {
23664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23665 }
23666 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23667 if (obj2) {
23668 ecode3 = SWIG_AsVal_int(obj2, &val3);
23669 if (!SWIG_IsOK(ecode3)) {
23670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23671 }
23672 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23673 }
23674 {
23675 PyThreadState* __tstate = wxPyBeginAllowThreads();
23676 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23677 wxPyEndAllowThreads(__tstate);
23678 if (PyErr_Occurred()) SWIG_fail;
23679 }
23680 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23681 return resultobj;
23682 fail:
23683 return NULL;
23684 }
23685
23686
23687 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23688 PyObject *resultobj = 0;
23689 wxDateTime *arg1 = (wxDateTime *) 0 ;
23690 wxDateTime::WeekDay arg2 ;
23691 wxDateTime *result = 0 ;
23692 void *argp1 = 0 ;
23693 int res1 = 0 ;
23694 int val2 ;
23695 int ecode2 = 0 ;
23696 PyObject * obj0 = 0 ;
23697 PyObject * obj1 = 0 ;
23698 char * kwnames[] = {
23699 (char *) "self",(char *) "weekday", NULL
23700 };
23701
23702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23704 if (!SWIG_IsOK(res1)) {
23705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23706 }
23707 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23708 ecode2 = SWIG_AsVal_int(obj1, &val2);
23709 if (!SWIG_IsOK(ecode2)) {
23710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23711 }
23712 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 {
23716 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23717 result = (wxDateTime *) &_result_ref;
23718 }
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23723 return resultobj;
23724 fail:
23725 return NULL;
23726 }
23727
23728
23729 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23730 PyObject *resultobj = 0;
23731 wxDateTime *arg1 = (wxDateTime *) 0 ;
23732 wxDateTime::WeekDay arg2 ;
23733 wxDateTime result;
23734 void *argp1 = 0 ;
23735 int res1 = 0 ;
23736 int val2 ;
23737 int ecode2 = 0 ;
23738 PyObject * obj0 = 0 ;
23739 PyObject * obj1 = 0 ;
23740 char * kwnames[] = {
23741 (char *) "self",(char *) "weekday", NULL
23742 };
23743
23744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23746 if (!SWIG_IsOK(res1)) {
23747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23748 }
23749 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23750 ecode2 = SWIG_AsVal_int(obj1, &val2);
23751 if (!SWIG_IsOK(ecode2)) {
23752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23753 }
23754 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = (arg1)->GetNextWeekDay(arg2);
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj = 0;
23770 wxDateTime *arg1 = (wxDateTime *) 0 ;
23771 wxDateTime::WeekDay arg2 ;
23772 wxDateTime *result = 0 ;
23773 void *argp1 = 0 ;
23774 int res1 = 0 ;
23775 int val2 ;
23776 int ecode2 = 0 ;
23777 PyObject * obj0 = 0 ;
23778 PyObject * obj1 = 0 ;
23779 char * kwnames[] = {
23780 (char *) "self",(char *) "weekday", NULL
23781 };
23782
23783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23785 if (!SWIG_IsOK(res1)) {
23786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23787 }
23788 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23789 ecode2 = SWIG_AsVal_int(obj1, &val2);
23790 if (!SWIG_IsOK(ecode2)) {
23791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23792 }
23793 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 {
23797 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23798 result = (wxDateTime *) &_result_ref;
23799 }
23800 wxPyEndAllowThreads(__tstate);
23801 if (PyErr_Occurred()) SWIG_fail;
23802 }
23803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23804 return resultobj;
23805 fail:
23806 return NULL;
23807 }
23808
23809
23810 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23811 PyObject *resultobj = 0;
23812 wxDateTime *arg1 = (wxDateTime *) 0 ;
23813 wxDateTime::WeekDay arg2 ;
23814 wxDateTime result;
23815 void *argp1 = 0 ;
23816 int res1 = 0 ;
23817 int val2 ;
23818 int ecode2 = 0 ;
23819 PyObject * obj0 = 0 ;
23820 PyObject * obj1 = 0 ;
23821 char * kwnames[] = {
23822 (char *) "self",(char *) "weekday", NULL
23823 };
23824
23825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23827 if (!SWIG_IsOK(res1)) {
23828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23829 }
23830 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23831 ecode2 = SWIG_AsVal_int(obj1, &val2);
23832 if (!SWIG_IsOK(ecode2)) {
23833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23834 }
23835 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23836 {
23837 PyThreadState* __tstate = wxPyBeginAllowThreads();
23838 result = (arg1)->GetPrevWeekDay(arg2);
23839 wxPyEndAllowThreads(__tstate);
23840 if (PyErr_Occurred()) SWIG_fail;
23841 }
23842 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23850 PyObject *resultobj = 0;
23851 wxDateTime *arg1 = (wxDateTime *) 0 ;
23852 wxDateTime::WeekDay arg2 ;
23853 int arg3 = (int) 1 ;
23854 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23855 int arg5 = (int) wxDateTime::Inv_Year ;
23856 bool result;
23857 void *argp1 = 0 ;
23858 int res1 = 0 ;
23859 int val2 ;
23860 int ecode2 = 0 ;
23861 int val3 ;
23862 int ecode3 = 0 ;
23863 int val4 ;
23864 int ecode4 = 0 ;
23865 int val5 ;
23866 int ecode5 = 0 ;
23867 PyObject * obj0 = 0 ;
23868 PyObject * obj1 = 0 ;
23869 PyObject * obj2 = 0 ;
23870 PyObject * obj3 = 0 ;
23871 PyObject * obj4 = 0 ;
23872 char * kwnames[] = {
23873 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23874 };
23875
23876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23880 }
23881 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23882 ecode2 = SWIG_AsVal_int(obj1, &val2);
23883 if (!SWIG_IsOK(ecode2)) {
23884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23885 }
23886 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23887 if (obj2) {
23888 ecode3 = SWIG_AsVal_int(obj2, &val3);
23889 if (!SWIG_IsOK(ecode3)) {
23890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23891 }
23892 arg3 = static_cast< int >(val3);
23893 }
23894 if (obj3) {
23895 ecode4 = SWIG_AsVal_int(obj3, &val4);
23896 if (!SWIG_IsOK(ecode4)) {
23897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23898 }
23899 arg4 = static_cast< wxDateTime::Month >(val4);
23900 }
23901 if (obj4) {
23902 ecode5 = SWIG_AsVal_int(obj4, &val5);
23903 if (!SWIG_IsOK(ecode5)) {
23904 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23905 }
23906 arg5 = static_cast< int >(val5);
23907 }
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 {
23915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23916 }
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23924 PyObject *resultobj = 0;
23925 wxDateTime *arg1 = (wxDateTime *) 0 ;
23926 wxDateTime::WeekDay arg2 ;
23927 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23928 int arg4 = (int) wxDateTime::Inv_Year ;
23929 bool result;
23930 void *argp1 = 0 ;
23931 int res1 = 0 ;
23932 int val2 ;
23933 int ecode2 = 0 ;
23934 int val3 ;
23935 int ecode3 = 0 ;
23936 int val4 ;
23937 int ecode4 = 0 ;
23938 PyObject * obj0 = 0 ;
23939 PyObject * obj1 = 0 ;
23940 PyObject * obj2 = 0 ;
23941 PyObject * obj3 = 0 ;
23942 char * kwnames[] = {
23943 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23944 };
23945
23946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23948 if (!SWIG_IsOK(res1)) {
23949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23950 }
23951 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23952 ecode2 = SWIG_AsVal_int(obj1, &val2);
23953 if (!SWIG_IsOK(ecode2)) {
23954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23955 }
23956 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23957 if (obj2) {
23958 ecode3 = SWIG_AsVal_int(obj2, &val3);
23959 if (!SWIG_IsOK(ecode3)) {
23960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23961 }
23962 arg3 = static_cast< wxDateTime::Month >(val3);
23963 }
23964 if (obj3) {
23965 ecode4 = SWIG_AsVal_int(obj3, &val4);
23966 if (!SWIG_IsOK(ecode4)) {
23967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23968 }
23969 arg4 = static_cast< int >(val4);
23970 }
23971 {
23972 PyThreadState* __tstate = wxPyBeginAllowThreads();
23973 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23974 wxPyEndAllowThreads(__tstate);
23975 if (PyErr_Occurred()) SWIG_fail;
23976 }
23977 {
23978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23979 }
23980 return resultobj;
23981 fail:
23982 return NULL;
23983 }
23984
23985
23986 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23987 PyObject *resultobj = 0;
23988 wxDateTime *arg1 = (wxDateTime *) 0 ;
23989 wxDateTime::WeekDay arg2 ;
23990 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23991 int arg4 = (int) wxDateTime::Inv_Year ;
23992 wxDateTime result;
23993 void *argp1 = 0 ;
23994 int res1 = 0 ;
23995 int val2 ;
23996 int ecode2 = 0 ;
23997 int val3 ;
23998 int ecode3 = 0 ;
23999 int val4 ;
24000 int ecode4 = 0 ;
24001 PyObject * obj0 = 0 ;
24002 PyObject * obj1 = 0 ;
24003 PyObject * obj2 = 0 ;
24004 PyObject * obj3 = 0 ;
24005 char * kwnames[] = {
24006 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24007 };
24008
24009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24011 if (!SWIG_IsOK(res1)) {
24012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24013 }
24014 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24015 ecode2 = SWIG_AsVal_int(obj1, &val2);
24016 if (!SWIG_IsOK(ecode2)) {
24017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24018 }
24019 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24020 if (obj2) {
24021 ecode3 = SWIG_AsVal_int(obj2, &val3);
24022 if (!SWIG_IsOK(ecode3)) {
24023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24024 }
24025 arg3 = static_cast< wxDateTime::Month >(val3);
24026 }
24027 if (obj3) {
24028 ecode4 = SWIG_AsVal_int(obj3, &val4);
24029 if (!SWIG_IsOK(ecode4)) {
24030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24031 }
24032 arg4 = static_cast< int >(val4);
24033 }
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24037 wxPyEndAllowThreads(__tstate);
24038 if (PyErr_Occurred()) SWIG_fail;
24039 }
24040 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24041 return resultobj;
24042 fail:
24043 return NULL;
24044 }
24045
24046
24047 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24048 PyObject *resultobj = 0;
24049 wxDateTime *arg1 = (wxDateTime *) 0 ;
24050 int arg2 ;
24051 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24052 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24053 bool result;
24054 void *argp1 = 0 ;
24055 int res1 = 0 ;
24056 int val2 ;
24057 int ecode2 = 0 ;
24058 int val3 ;
24059 int ecode3 = 0 ;
24060 int val4 ;
24061 int ecode4 = 0 ;
24062 PyObject * obj0 = 0 ;
24063 PyObject * obj1 = 0 ;
24064 PyObject * obj2 = 0 ;
24065 PyObject * obj3 = 0 ;
24066 char * kwnames[] = {
24067 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24068 };
24069
24070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24072 if (!SWIG_IsOK(res1)) {
24073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24074 }
24075 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24076 ecode2 = SWIG_AsVal_int(obj1, &val2);
24077 if (!SWIG_IsOK(ecode2)) {
24078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24079 }
24080 arg2 = static_cast< int >(val2);
24081 if (obj2) {
24082 ecode3 = SWIG_AsVal_int(obj2, &val3);
24083 if (!SWIG_IsOK(ecode3)) {
24084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24085 }
24086 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24087 }
24088 if (obj3) {
24089 ecode4 = SWIG_AsVal_int(obj3, &val4);
24090 if (!SWIG_IsOK(ecode4)) {
24091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24092 }
24093 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24094 }
24095 {
24096 PyThreadState* __tstate = wxPyBeginAllowThreads();
24097 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24098 wxPyEndAllowThreads(__tstate);
24099 if (PyErr_Occurred()) SWIG_fail;
24100 }
24101 {
24102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24103 }
24104 return resultobj;
24105 fail:
24106 return NULL;
24107 }
24108
24109
24110 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24111 PyObject *resultobj = 0;
24112 wxDateTime *arg1 = (wxDateTime *) 0 ;
24113 int arg2 ;
24114 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24115 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24116 wxDateTime result;
24117 void *argp1 = 0 ;
24118 int res1 = 0 ;
24119 int val2 ;
24120 int ecode2 = 0 ;
24121 int val3 ;
24122 int ecode3 = 0 ;
24123 int val4 ;
24124 int ecode4 = 0 ;
24125 PyObject * obj0 = 0 ;
24126 PyObject * obj1 = 0 ;
24127 PyObject * obj2 = 0 ;
24128 PyObject * obj3 = 0 ;
24129 char * kwnames[] = {
24130 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24131 };
24132
24133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24135 if (!SWIG_IsOK(res1)) {
24136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24137 }
24138 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24139 ecode2 = SWIG_AsVal_int(obj1, &val2);
24140 if (!SWIG_IsOK(ecode2)) {
24141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
24142 }
24143 arg2 = static_cast< int >(val2);
24144 if (obj2) {
24145 ecode3 = SWIG_AsVal_int(obj2, &val3);
24146 if (!SWIG_IsOK(ecode3)) {
24147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24148 }
24149 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24150 }
24151 if (obj3) {
24152 ecode4 = SWIG_AsVal_int(obj3, &val4);
24153 if (!SWIG_IsOK(ecode4)) {
24154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24155 }
24156 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24157 }
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = (arg1)->GetWeek(arg2,arg3,arg4);
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24172 PyObject *resultobj = 0;
24173 int arg1 ;
24174 int arg2 ;
24175 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24176 wxDateTime result;
24177 int val1 ;
24178 int ecode1 = 0 ;
24179 int val2 ;
24180 int ecode2 = 0 ;
24181 int val3 ;
24182 int ecode3 = 0 ;
24183 PyObject * obj0 = 0 ;
24184 PyObject * obj1 = 0 ;
24185 PyObject * obj2 = 0 ;
24186 char * kwnames[] = {
24187 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24188 };
24189
24190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24191 ecode1 = SWIG_AsVal_int(obj0, &val1);
24192 if (!SWIG_IsOK(ecode1)) {
24193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24194 }
24195 arg1 = static_cast< int >(val1);
24196 ecode2 = SWIG_AsVal_int(obj1, &val2);
24197 if (!SWIG_IsOK(ecode2)) {
24198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24199 }
24200 arg2 = static_cast< int >(val2);
24201 if (obj2) {
24202 ecode3 = SWIG_AsVal_int(obj2, &val3);
24203 if (!SWIG_IsOK(ecode3)) {
24204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24205 }
24206 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24207 }
24208 {
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
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_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24222 PyObject *resultobj = 0;
24223 wxDateTime *arg1 = (wxDateTime *) 0 ;
24224 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24225 int arg3 = (int) wxDateTime::Inv_Year ;
24226 wxDateTime *result = 0 ;
24227 void *argp1 = 0 ;
24228 int res1 = 0 ;
24229 int val2 ;
24230 int ecode2 = 0 ;
24231 int val3 ;
24232 int ecode3 = 0 ;
24233 PyObject * obj0 = 0 ;
24234 PyObject * obj1 = 0 ;
24235 PyObject * obj2 = 0 ;
24236 char * kwnames[] = {
24237 (char *) "self",(char *) "month",(char *) "year", NULL
24238 };
24239
24240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24242 if (!SWIG_IsOK(res1)) {
24243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24244 }
24245 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24246 if (obj1) {
24247 ecode2 = SWIG_AsVal_int(obj1, &val2);
24248 if (!SWIG_IsOK(ecode2)) {
24249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24250 }
24251 arg2 = static_cast< wxDateTime::Month >(val2);
24252 }
24253 if (obj2) {
24254 ecode3 = SWIG_AsVal_int(obj2, &val3);
24255 if (!SWIG_IsOK(ecode3)) {
24256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24257 }
24258 arg3 = static_cast< int >(val3);
24259 }
24260 {
24261 PyThreadState* __tstate = wxPyBeginAllowThreads();
24262 {
24263 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24264 result = (wxDateTime *) &_result_ref;
24265 }
24266 wxPyEndAllowThreads(__tstate);
24267 if (PyErr_Occurred()) SWIG_fail;
24268 }
24269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24270 return resultobj;
24271 fail:
24272 return NULL;
24273 }
24274
24275
24276 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24277 PyObject *resultobj = 0;
24278 wxDateTime *arg1 = (wxDateTime *) 0 ;
24279 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24280 int arg3 = (int) wxDateTime::Inv_Year ;
24281 wxDateTime result;
24282 void *argp1 = 0 ;
24283 int res1 = 0 ;
24284 int val2 ;
24285 int ecode2 = 0 ;
24286 int val3 ;
24287 int ecode3 = 0 ;
24288 PyObject * obj0 = 0 ;
24289 PyObject * obj1 = 0 ;
24290 PyObject * obj2 = 0 ;
24291 char * kwnames[] = {
24292 (char *) "self",(char *) "month",(char *) "year", NULL
24293 };
24294
24295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24297 if (!SWIG_IsOK(res1)) {
24298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24299 }
24300 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24301 if (obj1) {
24302 ecode2 = SWIG_AsVal_int(obj1, &val2);
24303 if (!SWIG_IsOK(ecode2)) {
24304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24305 }
24306 arg2 = static_cast< wxDateTime::Month >(val2);
24307 }
24308 if (obj2) {
24309 ecode3 = SWIG_AsVal_int(obj2, &val3);
24310 if (!SWIG_IsOK(ecode3)) {
24311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24312 }
24313 arg3 = static_cast< int >(val3);
24314 }
24315 {
24316 PyThreadState* __tstate = wxPyBeginAllowThreads();
24317 result = (arg1)->GetLastMonthDay(arg2,arg3);
24318 wxPyEndAllowThreads(__tstate);
24319 if (PyErr_Occurred()) SWIG_fail;
24320 }
24321 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24322 return resultobj;
24323 fail:
24324 return NULL;
24325 }
24326
24327
24328 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24329 PyObject *resultobj = 0;
24330 wxDateTime *arg1 = (wxDateTime *) 0 ;
24331 int arg2 ;
24332 wxDateTime *result = 0 ;
24333 void *argp1 = 0 ;
24334 int res1 = 0 ;
24335 int val2 ;
24336 int ecode2 = 0 ;
24337 PyObject * obj0 = 0 ;
24338 PyObject * obj1 = 0 ;
24339 char * kwnames[] = {
24340 (char *) "self",(char *) "yday", NULL
24341 };
24342
24343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24345 if (!SWIG_IsOK(res1)) {
24346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24347 }
24348 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24349 ecode2 = SWIG_AsVal_int(obj1, &val2);
24350 if (!SWIG_IsOK(ecode2)) {
24351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24352 }
24353 arg2 = static_cast< int >(val2);
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 {
24357 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24358 result = (wxDateTime *) &_result_ref;
24359 }
24360 wxPyEndAllowThreads(__tstate);
24361 if (PyErr_Occurred()) SWIG_fail;
24362 }
24363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24371 PyObject *resultobj = 0;
24372 wxDateTime *arg1 = (wxDateTime *) 0 ;
24373 int arg2 ;
24374 wxDateTime result;
24375 void *argp1 = 0 ;
24376 int res1 = 0 ;
24377 int val2 ;
24378 int ecode2 = 0 ;
24379 PyObject * obj0 = 0 ;
24380 PyObject * obj1 = 0 ;
24381 char * kwnames[] = {
24382 (char *) "self",(char *) "yday", NULL
24383 };
24384
24385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24387 if (!SWIG_IsOK(res1)) {
24388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24389 }
24390 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24391 ecode2 = SWIG_AsVal_int(obj1, &val2);
24392 if (!SWIG_IsOK(ecode2)) {
24393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24394 }
24395 arg2 = static_cast< int >(val2);
24396 {
24397 PyThreadState* __tstate = wxPyBeginAllowThreads();
24398 result = (arg1)->GetYearDay(arg2);
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 return resultobj;
24404 fail:
24405 return NULL;
24406 }
24407
24408
24409 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24410 PyObject *resultobj = 0;
24411 wxDateTime *arg1 = (wxDateTime *) 0 ;
24412 double result;
24413 void *argp1 = 0 ;
24414 int res1 = 0 ;
24415 PyObject *swig_obj[1] ;
24416
24417 if (!args) SWIG_fail;
24418 swig_obj[0] = args;
24419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24420 if (!SWIG_IsOK(res1)) {
24421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24422 }
24423 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24424 {
24425 PyThreadState* __tstate = wxPyBeginAllowThreads();
24426 result = (double)(arg1)->GetJulianDayNumber();
24427 wxPyEndAllowThreads(__tstate);
24428 if (PyErr_Occurred()) SWIG_fail;
24429 }
24430 resultobj = SWIG_From_double(static_cast< double >(result));
24431 return resultobj;
24432 fail:
24433 return NULL;
24434 }
24435
24436
24437 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24438 PyObject *resultobj = 0;
24439 wxDateTime *arg1 = (wxDateTime *) 0 ;
24440 double result;
24441 void *argp1 = 0 ;
24442 int res1 = 0 ;
24443 PyObject *swig_obj[1] ;
24444
24445 if (!args) SWIG_fail;
24446 swig_obj[0] = args;
24447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24448 if (!SWIG_IsOK(res1)) {
24449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24450 }
24451 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24452 {
24453 PyThreadState* __tstate = wxPyBeginAllowThreads();
24454 result = (double)(arg1)->GetJDN();
24455 wxPyEndAllowThreads(__tstate);
24456 if (PyErr_Occurred()) SWIG_fail;
24457 }
24458 resultobj = SWIG_From_double(static_cast< double >(result));
24459 return resultobj;
24460 fail:
24461 return NULL;
24462 }
24463
24464
24465 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24466 PyObject *resultobj = 0;
24467 wxDateTime *arg1 = (wxDateTime *) 0 ;
24468 double result;
24469 void *argp1 = 0 ;
24470 int res1 = 0 ;
24471 PyObject *swig_obj[1] ;
24472
24473 if (!args) SWIG_fail;
24474 swig_obj[0] = args;
24475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24476 if (!SWIG_IsOK(res1)) {
24477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24478 }
24479 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24480 {
24481 PyThreadState* __tstate = wxPyBeginAllowThreads();
24482 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24483 wxPyEndAllowThreads(__tstate);
24484 if (PyErr_Occurred()) SWIG_fail;
24485 }
24486 resultobj = SWIG_From_double(static_cast< double >(result));
24487 return resultobj;
24488 fail:
24489 return NULL;
24490 }
24491
24492
24493 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24494 PyObject *resultobj = 0;
24495 wxDateTime *arg1 = (wxDateTime *) 0 ;
24496 double result;
24497 void *argp1 = 0 ;
24498 int res1 = 0 ;
24499 PyObject *swig_obj[1] ;
24500
24501 if (!args) SWIG_fail;
24502 swig_obj[0] = args;
24503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24504 if (!SWIG_IsOK(res1)) {
24505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24506 }
24507 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24508 {
24509 PyThreadState* __tstate = wxPyBeginAllowThreads();
24510 result = (double)(arg1)->GetMJD();
24511 wxPyEndAllowThreads(__tstate);
24512 if (PyErr_Occurred()) SWIG_fail;
24513 }
24514 resultobj = SWIG_From_double(static_cast< double >(result));
24515 return resultobj;
24516 fail:
24517 return NULL;
24518 }
24519
24520
24521 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24522 PyObject *resultobj = 0;
24523 wxDateTime *arg1 = (wxDateTime *) 0 ;
24524 double result;
24525 void *argp1 = 0 ;
24526 int res1 = 0 ;
24527 PyObject *swig_obj[1] ;
24528
24529 if (!args) SWIG_fail;
24530 swig_obj[0] = args;
24531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24532 if (!SWIG_IsOK(res1)) {
24533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24534 }
24535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24536 {
24537 PyThreadState* __tstate = wxPyBeginAllowThreads();
24538 result = (double)(arg1)->GetRataDie();
24539 wxPyEndAllowThreads(__tstate);
24540 if (PyErr_Occurred()) SWIG_fail;
24541 }
24542 resultobj = SWIG_From_double(static_cast< double >(result));
24543 return resultobj;
24544 fail:
24545 return NULL;
24546 }
24547
24548
24549 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj = 0;
24551 wxDateTime *arg1 = (wxDateTime *) 0 ;
24552 wxDateTime::TimeZone *arg2 = 0 ;
24553 bool arg3 = (bool) false ;
24554 wxDateTime result;
24555 void *argp1 = 0 ;
24556 int res1 = 0 ;
24557 bool temp2 = false ;
24558 bool val3 ;
24559 int ecode3 = 0 ;
24560 PyObject * obj0 = 0 ;
24561 PyObject * obj1 = 0 ;
24562 PyObject * obj2 = 0 ;
24563 char * kwnames[] = {
24564 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24565 };
24566
24567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24569 if (!SWIG_IsOK(res1)) {
24570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24571 }
24572 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24573 {
24574 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24575 temp2 = true;
24576 }
24577 if (obj2) {
24578 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24579 if (!SWIG_IsOK(ecode3)) {
24580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24581 }
24582 arg3 = static_cast< bool >(val3);
24583 }
24584 {
24585 PyThreadState* __tstate = wxPyBeginAllowThreads();
24586 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24591 {
24592 if (temp2) delete arg2;
24593 }
24594 return resultobj;
24595 fail:
24596 {
24597 if (temp2) delete arg2;
24598 }
24599 return NULL;
24600 }
24601
24602
24603 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj = 0;
24605 wxDateTime *arg1 = (wxDateTime *) 0 ;
24606 wxDateTime::TimeZone *arg2 = 0 ;
24607 bool arg3 = (bool) false ;
24608 wxDateTime *result = 0 ;
24609 void *argp1 = 0 ;
24610 int res1 = 0 ;
24611 bool temp2 = false ;
24612 bool val3 ;
24613 int ecode3 = 0 ;
24614 PyObject * obj0 = 0 ;
24615 PyObject * obj1 = 0 ;
24616 PyObject * obj2 = 0 ;
24617 char * kwnames[] = {
24618 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24619 };
24620
24621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24623 if (!SWIG_IsOK(res1)) {
24624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24625 }
24626 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24627 {
24628 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24629 temp2 = true;
24630 }
24631 if (obj2) {
24632 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24633 if (!SWIG_IsOK(ecode3)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24635 }
24636 arg3 = static_cast< bool >(val3);
24637 }
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 {
24641 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24642 result = (wxDateTime *) &_result_ref;
24643 }
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24648 {
24649 if (temp2) delete arg2;
24650 }
24651 return resultobj;
24652 fail:
24653 {
24654 if (temp2) delete arg2;
24655 }
24656 return NULL;
24657 }
24658
24659
24660 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj = 0;
24662 wxDateTime *arg1 = (wxDateTime *) 0 ;
24663 wxDateTime::TimeZone *arg2 = 0 ;
24664 bool arg3 = (bool) false ;
24665 wxDateTime result;
24666 void *argp1 = 0 ;
24667 int res1 = 0 ;
24668 bool temp2 = false ;
24669 bool val3 ;
24670 int ecode3 = 0 ;
24671 PyObject * obj0 = 0 ;
24672 PyObject * obj1 = 0 ;
24673 PyObject * obj2 = 0 ;
24674 char * kwnames[] = {
24675 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24676 };
24677
24678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24680 if (!SWIG_IsOK(res1)) {
24681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24682 }
24683 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24684 {
24685 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24686 temp2 = true;
24687 }
24688 if (obj2) {
24689 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24690 if (!SWIG_IsOK(ecode3)) {
24691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24692 }
24693 arg3 = static_cast< bool >(val3);
24694 }
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24698 wxPyEndAllowThreads(__tstate);
24699 if (PyErr_Occurred()) SWIG_fail;
24700 }
24701 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24702 {
24703 if (temp2) delete arg2;
24704 }
24705 return resultobj;
24706 fail:
24707 {
24708 if (temp2) delete arg2;
24709 }
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 wxDateTime *arg1 = (wxDateTime *) 0 ;
24717 wxDateTime::TimeZone *arg2 = 0 ;
24718 bool arg3 = (bool) false ;
24719 wxDateTime *result = 0 ;
24720 void *argp1 = 0 ;
24721 int res1 = 0 ;
24722 bool temp2 = false ;
24723 bool val3 ;
24724 int ecode3 = 0 ;
24725 PyObject * obj0 = 0 ;
24726 PyObject * obj1 = 0 ;
24727 PyObject * obj2 = 0 ;
24728 char * kwnames[] = {
24729 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24730 };
24731
24732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24734 if (!SWIG_IsOK(res1)) {
24735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24736 }
24737 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24738 {
24739 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24740 temp2 = true;
24741 }
24742 if (obj2) {
24743 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24744 if (!SWIG_IsOK(ecode3)) {
24745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24746 }
24747 arg3 = static_cast< bool >(val3);
24748 }
24749 {
24750 PyThreadState* __tstate = wxPyBeginAllowThreads();
24751 {
24752 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24753 result = (wxDateTime *) &_result_ref;
24754 }
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24759 {
24760 if (temp2) delete arg2;
24761 }
24762 return resultobj;
24763 fail:
24764 {
24765 if (temp2) delete arg2;
24766 }
24767 return NULL;
24768 }
24769
24770
24771 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24772 PyObject *resultobj = 0;
24773 wxDateTime *arg1 = (wxDateTime *) 0 ;
24774 bool arg2 = (bool) false ;
24775 wxDateTime result;
24776 void *argp1 = 0 ;
24777 int res1 = 0 ;
24778 bool val2 ;
24779 int ecode2 = 0 ;
24780 PyObject * obj0 = 0 ;
24781 PyObject * obj1 = 0 ;
24782 char * kwnames[] = {
24783 (char *) "self",(char *) "noDST", NULL
24784 };
24785
24786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24788 if (!SWIG_IsOK(res1)) {
24789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24790 }
24791 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24792 if (obj1) {
24793 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24794 if (!SWIG_IsOK(ecode2)) {
24795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24796 }
24797 arg2 = static_cast< bool >(val2);
24798 }
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24813 PyObject *resultobj = 0;
24814 wxDateTime *arg1 = (wxDateTime *) 0 ;
24815 bool arg2 = (bool) false ;
24816 wxDateTime *result = 0 ;
24817 void *argp1 = 0 ;
24818 int res1 = 0 ;
24819 bool val2 ;
24820 int ecode2 = 0 ;
24821 PyObject * obj0 = 0 ;
24822 PyObject * obj1 = 0 ;
24823 char * kwnames[] = {
24824 (char *) "self",(char *) "noDST", NULL
24825 };
24826
24827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24829 if (!SWIG_IsOK(res1)) {
24830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24831 }
24832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24833 if (obj1) {
24834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24835 if (!SWIG_IsOK(ecode2)) {
24836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24837 }
24838 arg2 = static_cast< bool >(val2);
24839 }
24840 {
24841 PyThreadState* __tstate = wxPyBeginAllowThreads();
24842 {
24843 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24844 result = (wxDateTime *) &_result_ref;
24845 }
24846 wxPyEndAllowThreads(__tstate);
24847 if (PyErr_Occurred()) SWIG_fail;
24848 }
24849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24850 return resultobj;
24851 fail:
24852 return NULL;
24853 }
24854
24855
24856 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24857 PyObject *resultobj = 0;
24858 wxDateTime *arg1 = (wxDateTime *) 0 ;
24859 bool arg2 = (bool) false ;
24860 wxDateTime result;
24861 void *argp1 = 0 ;
24862 int res1 = 0 ;
24863 bool val2 ;
24864 int ecode2 = 0 ;
24865 PyObject * obj0 = 0 ;
24866 PyObject * obj1 = 0 ;
24867 char * kwnames[] = {
24868 (char *) "self",(char *) "noDST", NULL
24869 };
24870
24871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24875 }
24876 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24877 if (obj1) {
24878 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24879 if (!SWIG_IsOK(ecode2)) {
24880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24881 }
24882 arg2 = static_cast< bool >(val2);
24883 }
24884 {
24885 PyThreadState* __tstate = wxPyBeginAllowThreads();
24886 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24887 wxPyEndAllowThreads(__tstate);
24888 if (PyErr_Occurred()) SWIG_fail;
24889 }
24890 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24891 return resultobj;
24892 fail:
24893 return NULL;
24894 }
24895
24896
24897 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24898 PyObject *resultobj = 0;
24899 wxDateTime *arg1 = (wxDateTime *) 0 ;
24900 bool arg2 = (bool) false ;
24901 wxDateTime *result = 0 ;
24902 void *argp1 = 0 ;
24903 int res1 = 0 ;
24904 bool val2 ;
24905 int ecode2 = 0 ;
24906 PyObject * obj0 = 0 ;
24907 PyObject * obj1 = 0 ;
24908 char * kwnames[] = {
24909 (char *) "self",(char *) "noDST", NULL
24910 };
24911
24912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24914 if (!SWIG_IsOK(res1)) {
24915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24916 }
24917 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24918 if (obj1) {
24919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24920 if (!SWIG_IsOK(ecode2)) {
24921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24922 }
24923 arg2 = static_cast< bool >(val2);
24924 }
24925 {
24926 PyThreadState* __tstate = wxPyBeginAllowThreads();
24927 {
24928 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24929 result = (wxDateTime *) &_result_ref;
24930 }
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24935 return resultobj;
24936 fail:
24937 return NULL;
24938 }
24939
24940
24941 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24942 PyObject *resultobj = 0;
24943 wxDateTime *arg1 = (wxDateTime *) 0 ;
24944 bool arg2 = (bool) false ;
24945 wxDateTime result;
24946 void *argp1 = 0 ;
24947 int res1 = 0 ;
24948 bool val2 ;
24949 int ecode2 = 0 ;
24950 PyObject * obj0 = 0 ;
24951 PyObject * obj1 = 0 ;
24952 char * kwnames[] = {
24953 (char *) "self",(char *) "noDST", NULL
24954 };
24955
24956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24958 if (!SWIG_IsOK(res1)) {
24959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24960 }
24961 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24962 if (obj1) {
24963 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24964 if (!SWIG_IsOK(ecode2)) {
24965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24966 }
24967 arg2 = static_cast< bool >(val2);
24968 }
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24976 return resultobj;
24977 fail:
24978 return NULL;
24979 }
24980
24981
24982 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24983 PyObject *resultobj = 0;
24984 wxDateTime *arg1 = (wxDateTime *) 0 ;
24985 bool arg2 = (bool) false ;
24986 wxDateTime *result = 0 ;
24987 void *argp1 = 0 ;
24988 int res1 = 0 ;
24989 bool val2 ;
24990 int ecode2 = 0 ;
24991 PyObject * obj0 = 0 ;
24992 PyObject * obj1 = 0 ;
24993 char * kwnames[] = {
24994 (char *) "self",(char *) "noDST", NULL
24995 };
24996
24997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24999 if (!SWIG_IsOK(res1)) {
25000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25001 }
25002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25003 if (obj1) {
25004 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25005 if (!SWIG_IsOK(ecode2)) {
25006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25007 }
25008 arg2 = static_cast< bool >(val2);
25009 }
25010 {
25011 PyThreadState* __tstate = wxPyBeginAllowThreads();
25012 {
25013 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25014 result = (wxDateTime *) &_result_ref;
25015 }
25016 wxPyEndAllowThreads(__tstate);
25017 if (PyErr_Occurred()) SWIG_fail;
25018 }
25019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25020 return resultobj;
25021 fail:
25022 return NULL;
25023 }
25024
25025
25026 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25027 PyObject *resultobj = 0;
25028 wxDateTime *arg1 = (wxDateTime *) 0 ;
25029 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25030 int result;
25031 void *argp1 = 0 ;
25032 int res1 = 0 ;
25033 int val2 ;
25034 int ecode2 = 0 ;
25035 PyObject * obj0 = 0 ;
25036 PyObject * obj1 = 0 ;
25037 char * kwnames[] = {
25038 (char *) "self",(char *) "country", NULL
25039 };
25040
25041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25043 if (!SWIG_IsOK(res1)) {
25044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
25045 }
25046 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25047 if (obj1) {
25048 ecode2 = SWIG_AsVal_int(obj1, &val2);
25049 if (!SWIG_IsOK(ecode2)) {
25050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25051 }
25052 arg2 = static_cast< wxDateTime::Country >(val2);
25053 }
25054 {
25055 PyThreadState* __tstate = wxPyBeginAllowThreads();
25056 result = (int)(arg1)->IsDST(arg2);
25057 wxPyEndAllowThreads(__tstate);
25058 if (PyErr_Occurred()) SWIG_fail;
25059 }
25060 resultobj = SWIG_From_int(static_cast< int >(result));
25061 return resultobj;
25062 fail:
25063 return NULL;
25064 }
25065
25066
25067 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25068 PyObject *resultobj = 0;
25069 wxDateTime *arg1 = (wxDateTime *) 0 ;
25070 bool result;
25071 void *argp1 = 0 ;
25072 int res1 = 0 ;
25073 PyObject *swig_obj[1] ;
25074
25075 if (!args) SWIG_fail;
25076 swig_obj[0] = args;
25077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25078 if (!SWIG_IsOK(res1)) {
25079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25080 }
25081 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25082 {
25083 PyThreadState* __tstate = wxPyBeginAllowThreads();
25084 result = (bool)((wxDateTime const *)arg1)->IsValid();
25085 wxPyEndAllowThreads(__tstate);
25086 if (PyErr_Occurred()) SWIG_fail;
25087 }
25088 {
25089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25090 }
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25098 PyObject *resultobj = 0;
25099 wxDateTime *arg1 = (wxDateTime *) 0 ;
25100 time_t result;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 PyObject *swig_obj[1] ;
25104
25105 if (!args) SWIG_fail;
25106 swig_obj[0] = args;
25107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25108 if (!SWIG_IsOK(res1)) {
25109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25110 }
25111 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25112 {
25113 PyThreadState* __tstate = wxPyBeginAllowThreads();
25114 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
25115 wxPyEndAllowThreads(__tstate);
25116 if (PyErr_Occurred()) SWIG_fail;
25117 }
25118 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25119 return resultobj;
25120 fail:
25121 return NULL;
25122 }
25123
25124
25125 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25126 PyObject *resultobj = 0;
25127 wxDateTime *arg1 = (wxDateTime *) 0 ;
25128 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25129 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25130 int result;
25131 void *argp1 = 0 ;
25132 int res1 = 0 ;
25133 bool temp2 = false ;
25134 PyObject * obj0 = 0 ;
25135 PyObject * obj1 = 0 ;
25136 char * kwnames[] = {
25137 (char *) "self",(char *) "tz", NULL
25138 };
25139
25140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
25141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25142 if (!SWIG_IsOK(res1)) {
25143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25144 }
25145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25146 if (obj1) {
25147 {
25148 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25149 temp2 = true;
25150 }
25151 }
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 resultobj = SWIG_From_int(static_cast< int >(result));
25159 {
25160 if (temp2) delete arg2;
25161 }
25162 return resultobj;
25163 fail:
25164 {
25165 if (temp2) delete arg2;
25166 }
25167 return NULL;
25168 }
25169
25170
25171 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25172 PyObject *resultobj = 0;
25173 wxDateTime *arg1 = (wxDateTime *) 0 ;
25174 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25175 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25176 wxDateTime::Month result;
25177 void *argp1 = 0 ;
25178 int res1 = 0 ;
25179 bool temp2 = false ;
25180 PyObject * obj0 = 0 ;
25181 PyObject * obj1 = 0 ;
25182 char * kwnames[] = {
25183 (char *) "self",(char *) "tz", NULL
25184 };
25185
25186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25188 if (!SWIG_IsOK(res1)) {
25189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25190 }
25191 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25192 if (obj1) {
25193 {
25194 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25195 temp2 = true;
25196 }
25197 }
25198 {
25199 PyThreadState* __tstate = wxPyBeginAllowThreads();
25200 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25201 wxPyEndAllowThreads(__tstate);
25202 if (PyErr_Occurred()) SWIG_fail;
25203 }
25204 resultobj = SWIG_From_int(static_cast< int >(result));
25205 {
25206 if (temp2) delete arg2;
25207 }
25208 return resultobj;
25209 fail:
25210 {
25211 if (temp2) delete arg2;
25212 }
25213 return NULL;
25214 }
25215
25216
25217 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj = 0;
25219 wxDateTime *arg1 = (wxDateTime *) 0 ;
25220 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25221 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25222 int result;
25223 void *argp1 = 0 ;
25224 int res1 = 0 ;
25225 bool temp2 = false ;
25226 PyObject * obj0 = 0 ;
25227 PyObject * obj1 = 0 ;
25228 char * kwnames[] = {
25229 (char *) "self",(char *) "tz", NULL
25230 };
25231
25232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25234 if (!SWIG_IsOK(res1)) {
25235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25236 }
25237 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25238 if (obj1) {
25239 {
25240 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25241 temp2 = true;
25242 }
25243 }
25244 {
25245 PyThreadState* __tstate = wxPyBeginAllowThreads();
25246 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 resultobj = SWIG_From_int(static_cast< int >(result));
25251 {
25252 if (temp2) delete arg2;
25253 }
25254 return resultobj;
25255 fail:
25256 {
25257 if (temp2) delete arg2;
25258 }
25259 return NULL;
25260 }
25261
25262
25263 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25264 PyObject *resultobj = 0;
25265 wxDateTime *arg1 = (wxDateTime *) 0 ;
25266 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25267 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25268 wxDateTime::WeekDay result;
25269 void *argp1 = 0 ;
25270 int res1 = 0 ;
25271 bool temp2 = false ;
25272 PyObject * obj0 = 0 ;
25273 PyObject * obj1 = 0 ;
25274 char * kwnames[] = {
25275 (char *) "self",(char *) "tz", NULL
25276 };
25277
25278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25280 if (!SWIG_IsOK(res1)) {
25281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25282 }
25283 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25284 if (obj1) {
25285 {
25286 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25287 temp2 = true;
25288 }
25289 }
25290 {
25291 PyThreadState* __tstate = wxPyBeginAllowThreads();
25292 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 resultobj = SWIG_From_int(static_cast< int >(result));
25297 {
25298 if (temp2) delete arg2;
25299 }
25300 return resultobj;
25301 fail:
25302 {
25303 if (temp2) delete arg2;
25304 }
25305 return NULL;
25306 }
25307
25308
25309 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25310 PyObject *resultobj = 0;
25311 wxDateTime *arg1 = (wxDateTime *) 0 ;
25312 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25313 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25314 int result;
25315 void *argp1 = 0 ;
25316 int res1 = 0 ;
25317 bool temp2 = false ;
25318 PyObject * obj0 = 0 ;
25319 PyObject * obj1 = 0 ;
25320 char * kwnames[] = {
25321 (char *) "self",(char *) "tz", NULL
25322 };
25323
25324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25326 if (!SWIG_IsOK(res1)) {
25327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25328 }
25329 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25330 if (obj1) {
25331 {
25332 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25333 temp2 = true;
25334 }
25335 }
25336 {
25337 PyThreadState* __tstate = wxPyBeginAllowThreads();
25338 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 resultobj = SWIG_From_int(static_cast< int >(result));
25343 {
25344 if (temp2) delete arg2;
25345 }
25346 return resultobj;
25347 fail:
25348 {
25349 if (temp2) delete arg2;
25350 }
25351 return NULL;
25352 }
25353
25354
25355 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25356 PyObject *resultobj = 0;
25357 wxDateTime *arg1 = (wxDateTime *) 0 ;
25358 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25359 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25360 int result;
25361 void *argp1 = 0 ;
25362 int res1 = 0 ;
25363 bool temp2 = false ;
25364 PyObject * obj0 = 0 ;
25365 PyObject * obj1 = 0 ;
25366 char * kwnames[] = {
25367 (char *) "self",(char *) "tz", NULL
25368 };
25369
25370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) 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_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25374 }
25375 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25376 if (obj1) {
25377 {
25378 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25379 temp2 = true;
25380 }
25381 }
25382 {
25383 PyThreadState* __tstate = wxPyBeginAllowThreads();
25384 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25385 wxPyEndAllowThreads(__tstate);
25386 if (PyErr_Occurred()) SWIG_fail;
25387 }
25388 resultobj = SWIG_From_int(static_cast< int >(result));
25389 {
25390 if (temp2) delete arg2;
25391 }
25392 return resultobj;
25393 fail:
25394 {
25395 if (temp2) delete arg2;
25396 }
25397 return NULL;
25398 }
25399
25400
25401 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25402 PyObject *resultobj = 0;
25403 wxDateTime *arg1 = (wxDateTime *) 0 ;
25404 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25405 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25406 int result;
25407 void *argp1 = 0 ;
25408 int res1 = 0 ;
25409 bool temp2 = false ;
25410 PyObject * obj0 = 0 ;
25411 PyObject * obj1 = 0 ;
25412 char * kwnames[] = {
25413 (char *) "self",(char *) "tz", NULL
25414 };
25415
25416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25418 if (!SWIG_IsOK(res1)) {
25419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25420 }
25421 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25422 if (obj1) {
25423 {
25424 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25425 temp2 = true;
25426 }
25427 }
25428 {
25429 PyThreadState* __tstate = wxPyBeginAllowThreads();
25430 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25431 wxPyEndAllowThreads(__tstate);
25432 if (PyErr_Occurred()) SWIG_fail;
25433 }
25434 resultobj = SWIG_From_int(static_cast< int >(result));
25435 {
25436 if (temp2) delete arg2;
25437 }
25438 return resultobj;
25439 fail:
25440 {
25441 if (temp2) delete arg2;
25442 }
25443 return NULL;
25444 }
25445
25446
25447 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25448 PyObject *resultobj = 0;
25449 wxDateTime *arg1 = (wxDateTime *) 0 ;
25450 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25451 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25452 int result;
25453 void *argp1 = 0 ;
25454 int res1 = 0 ;
25455 bool temp2 = false ;
25456 PyObject * obj0 = 0 ;
25457 PyObject * obj1 = 0 ;
25458 char * kwnames[] = {
25459 (char *) "self",(char *) "tz", NULL
25460 };
25461
25462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25464 if (!SWIG_IsOK(res1)) {
25465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25466 }
25467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25468 if (obj1) {
25469 {
25470 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25471 temp2 = true;
25472 }
25473 }
25474 {
25475 PyThreadState* __tstate = wxPyBeginAllowThreads();
25476 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25477 wxPyEndAllowThreads(__tstate);
25478 if (PyErr_Occurred()) SWIG_fail;
25479 }
25480 resultobj = SWIG_From_int(static_cast< int >(result));
25481 {
25482 if (temp2) delete arg2;
25483 }
25484 return resultobj;
25485 fail:
25486 {
25487 if (temp2) delete arg2;
25488 }
25489 return NULL;
25490 }
25491
25492
25493 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25494 PyObject *resultobj = 0;
25495 wxDateTime *arg1 = (wxDateTime *) 0 ;
25496 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25497 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25498 int result;
25499 void *argp1 = 0 ;
25500 int res1 = 0 ;
25501 bool temp2 = false ;
25502 PyObject * obj0 = 0 ;
25503 PyObject * obj1 = 0 ;
25504 char * kwnames[] = {
25505 (char *) "self",(char *) "tz", NULL
25506 };
25507
25508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25510 if (!SWIG_IsOK(res1)) {
25511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25512 }
25513 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25514 if (obj1) {
25515 {
25516 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25517 temp2 = true;
25518 }
25519 }
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25523 wxPyEndAllowThreads(__tstate);
25524 if (PyErr_Occurred()) SWIG_fail;
25525 }
25526 resultobj = SWIG_From_int(static_cast< int >(result));
25527 {
25528 if (temp2) delete arg2;
25529 }
25530 return resultobj;
25531 fail:
25532 {
25533 if (temp2) delete arg2;
25534 }
25535 return NULL;
25536 }
25537
25538
25539 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj = 0;
25541 wxDateTime *arg1 = (wxDateTime *) 0 ;
25542 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25543 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25544 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25545 int result;
25546 void *argp1 = 0 ;
25547 int res1 = 0 ;
25548 int val2 ;
25549 int ecode2 = 0 ;
25550 bool temp3 = false ;
25551 PyObject * obj0 = 0 ;
25552 PyObject * obj1 = 0 ;
25553 PyObject * obj2 = 0 ;
25554 char * kwnames[] = {
25555 (char *) "self",(char *) "flags",(char *) "tz", NULL
25556 };
25557
25558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25560 if (!SWIG_IsOK(res1)) {
25561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25562 }
25563 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25564 if (obj1) {
25565 ecode2 = SWIG_AsVal_int(obj1, &val2);
25566 if (!SWIG_IsOK(ecode2)) {
25567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25568 }
25569 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25570 }
25571 if (obj2) {
25572 {
25573 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25574 temp3 = true;
25575 }
25576 }
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_From_int(static_cast< int >(result));
25584 {
25585 if (temp3) delete arg3;
25586 }
25587 return resultobj;
25588 fail:
25589 {
25590 if (temp3) delete arg3;
25591 }
25592 return NULL;
25593 }
25594
25595
25596 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25597 PyObject *resultobj = 0;
25598 wxDateTime *arg1 = (wxDateTime *) 0 ;
25599 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25600 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25601 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25602 int result;
25603 void *argp1 = 0 ;
25604 int res1 = 0 ;
25605 int val2 ;
25606 int ecode2 = 0 ;
25607 bool temp3 = false ;
25608 PyObject * obj0 = 0 ;
25609 PyObject * obj1 = 0 ;
25610 PyObject * obj2 = 0 ;
25611 char * kwnames[] = {
25612 (char *) "self",(char *) "flags",(char *) "tz", NULL
25613 };
25614
25615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25617 if (!SWIG_IsOK(res1)) {
25618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25619 }
25620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25621 if (obj1) {
25622 ecode2 = SWIG_AsVal_int(obj1, &val2);
25623 if (!SWIG_IsOK(ecode2)) {
25624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25625 }
25626 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25627 }
25628 if (obj2) {
25629 {
25630 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25631 temp3 = true;
25632 }
25633 }
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_From_int(static_cast< int >(result));
25641 {
25642 if (temp3) delete arg3;
25643 }
25644 return resultobj;
25645 fail:
25646 {
25647 if (temp3) delete arg3;
25648 }
25649 return NULL;
25650 }
25651
25652
25653 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25654 PyObject *resultobj = 0;
25655 wxDateTime *arg1 = (wxDateTime *) 0 ;
25656 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25657 bool result;
25658 void *argp1 = 0 ;
25659 int res1 = 0 ;
25660 int val2 ;
25661 int ecode2 = 0 ;
25662 PyObject * obj0 = 0 ;
25663 PyObject * obj1 = 0 ;
25664 char * kwnames[] = {
25665 (char *) "self",(char *) "country", NULL
25666 };
25667
25668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25670 if (!SWIG_IsOK(res1)) {
25671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25672 }
25673 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25674 if (obj1) {
25675 ecode2 = SWIG_AsVal_int(obj1, &val2);
25676 if (!SWIG_IsOK(ecode2)) {
25677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25678 }
25679 arg2 = static_cast< wxDateTime::Country >(val2);
25680 }
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
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_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj = 0;
25698 wxDateTime *arg1 = (wxDateTime *) 0 ;
25699 wxDateTime *arg2 = 0 ;
25700 bool result;
25701 void *argp1 = 0 ;
25702 int res1 = 0 ;
25703 void *argp2 = 0 ;
25704 int res2 = 0 ;
25705 PyObject * obj0 = 0 ;
25706 PyObject * obj1 = 0 ;
25707 char * kwnames[] = {
25708 (char *) "self",(char *) "datetime", NULL
25709 };
25710
25711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25713 if (!SWIG_IsOK(res1)) {
25714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25715 }
25716 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25718 if (!SWIG_IsOK(res2)) {
25719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25720 }
25721 if (!argp2) {
25722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25723 }
25724 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25725 {
25726 PyThreadState* __tstate = wxPyBeginAllowThreads();
25727 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25728 wxPyEndAllowThreads(__tstate);
25729 if (PyErr_Occurred()) SWIG_fail;
25730 }
25731 {
25732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25733 }
25734 return resultobj;
25735 fail:
25736 return NULL;
25737 }
25738
25739
25740 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25741 PyObject *resultobj = 0;
25742 wxDateTime *arg1 = (wxDateTime *) 0 ;
25743 wxDateTime *arg2 = 0 ;
25744 bool result;
25745 void *argp1 = 0 ;
25746 int res1 = 0 ;
25747 void *argp2 = 0 ;
25748 int res2 = 0 ;
25749 PyObject * obj0 = 0 ;
25750 PyObject * obj1 = 0 ;
25751 char * kwnames[] = {
25752 (char *) "self",(char *) "datetime", NULL
25753 };
25754
25755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25757 if (!SWIG_IsOK(res1)) {
25758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25759 }
25760 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25761 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25762 if (!SWIG_IsOK(res2)) {
25763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25764 }
25765 if (!argp2) {
25766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25767 }
25768 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25769 {
25770 PyThreadState* __tstate = wxPyBeginAllowThreads();
25771 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25772 wxPyEndAllowThreads(__tstate);
25773 if (PyErr_Occurred()) SWIG_fail;
25774 }
25775 {
25776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25777 }
25778 return resultobj;
25779 fail:
25780 return NULL;
25781 }
25782
25783
25784 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25785 PyObject *resultobj = 0;
25786 wxDateTime *arg1 = (wxDateTime *) 0 ;
25787 wxDateTime *arg2 = 0 ;
25788 bool result;
25789 void *argp1 = 0 ;
25790 int res1 = 0 ;
25791 void *argp2 = 0 ;
25792 int res2 = 0 ;
25793 PyObject * obj0 = 0 ;
25794 PyObject * obj1 = 0 ;
25795 char * kwnames[] = {
25796 (char *) "self",(char *) "datetime", NULL
25797 };
25798
25799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25801 if (!SWIG_IsOK(res1)) {
25802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25803 }
25804 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25805 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25806 if (!SWIG_IsOK(res2)) {
25807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25808 }
25809 if (!argp2) {
25810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25811 }
25812 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 {
25820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25821 }
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25829 PyObject *resultobj = 0;
25830 wxDateTime *arg1 = (wxDateTime *) 0 ;
25831 wxDateTime *arg2 = 0 ;
25832 wxDateTime *arg3 = 0 ;
25833 bool result;
25834 void *argp1 = 0 ;
25835 int res1 = 0 ;
25836 void *argp2 = 0 ;
25837 int res2 = 0 ;
25838 void *argp3 = 0 ;
25839 int res3 = 0 ;
25840 PyObject * obj0 = 0 ;
25841 PyObject * obj1 = 0 ;
25842 PyObject * obj2 = 0 ;
25843 char * kwnames[] = {
25844 (char *) "self",(char *) "t1",(char *) "t2", NULL
25845 };
25846
25847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25849 if (!SWIG_IsOK(res1)) {
25850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25851 }
25852 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25853 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25854 if (!SWIG_IsOK(res2)) {
25855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25856 }
25857 if (!argp2) {
25858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25859 }
25860 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25861 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25862 if (!SWIG_IsOK(res3)) {
25863 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25864 }
25865 if (!argp3) {
25866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25867 }
25868 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 {
25876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25877 }
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25885 PyObject *resultobj = 0;
25886 wxDateTime *arg1 = (wxDateTime *) 0 ;
25887 wxDateTime *arg2 = 0 ;
25888 wxDateTime *arg3 = 0 ;
25889 bool result;
25890 void *argp1 = 0 ;
25891 int res1 = 0 ;
25892 void *argp2 = 0 ;
25893 int res2 = 0 ;
25894 void *argp3 = 0 ;
25895 int res3 = 0 ;
25896 PyObject * obj0 = 0 ;
25897 PyObject * obj1 = 0 ;
25898 PyObject * obj2 = 0 ;
25899 char * kwnames[] = {
25900 (char *) "self",(char *) "t1",(char *) "t2", NULL
25901 };
25902
25903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25905 if (!SWIG_IsOK(res1)) {
25906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25907 }
25908 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25910 if (!SWIG_IsOK(res2)) {
25911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25912 }
25913 if (!argp2) {
25914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25915 }
25916 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25917 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25918 if (!SWIG_IsOK(res3)) {
25919 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25920 }
25921 if (!argp3) {
25922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25923 }
25924 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25925 {
25926 PyThreadState* __tstate = wxPyBeginAllowThreads();
25927 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25928 wxPyEndAllowThreads(__tstate);
25929 if (PyErr_Occurred()) SWIG_fail;
25930 }
25931 {
25932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25933 }
25934 return resultobj;
25935 fail:
25936 return NULL;
25937 }
25938
25939
25940 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25941 PyObject *resultobj = 0;
25942 wxDateTime *arg1 = (wxDateTime *) 0 ;
25943 wxDateTime *arg2 = 0 ;
25944 bool result;
25945 void *argp1 = 0 ;
25946 int res1 = 0 ;
25947 void *argp2 = 0 ;
25948 int res2 = 0 ;
25949 PyObject * obj0 = 0 ;
25950 PyObject * obj1 = 0 ;
25951 char * kwnames[] = {
25952 (char *) "self",(char *) "dt", NULL
25953 };
25954
25955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25957 if (!SWIG_IsOK(res1)) {
25958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25959 }
25960 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25962 if (!SWIG_IsOK(res2)) {
25963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25964 }
25965 if (!argp2) {
25966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25967 }
25968 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25969 {
25970 PyThreadState* __tstate = wxPyBeginAllowThreads();
25971 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25972 wxPyEndAllowThreads(__tstate);
25973 if (PyErr_Occurred()) SWIG_fail;
25974 }
25975 {
25976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25977 }
25978 return resultobj;
25979 fail:
25980 return NULL;
25981 }
25982
25983
25984 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25985 PyObject *resultobj = 0;
25986 wxDateTime *arg1 = (wxDateTime *) 0 ;
25987 wxDateTime *arg2 = 0 ;
25988 bool result;
25989 void *argp1 = 0 ;
25990 int res1 = 0 ;
25991 void *argp2 = 0 ;
25992 int res2 = 0 ;
25993 PyObject * obj0 = 0 ;
25994 PyObject * obj1 = 0 ;
25995 char * kwnames[] = {
25996 (char *) "self",(char *) "dt", NULL
25997 };
25998
25999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26001 if (!SWIG_IsOK(res1)) {
26002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26003 }
26004 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26006 if (!SWIG_IsOK(res2)) {
26007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26008 }
26009 if (!argp2) {
26010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26011 }
26012 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26013 {
26014 PyThreadState* __tstate = wxPyBeginAllowThreads();
26015 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26016 wxPyEndAllowThreads(__tstate);
26017 if (PyErr_Occurred()) SWIG_fail;
26018 }
26019 {
26020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26021 }
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj = 0;
26030 wxDateTime *arg1 = (wxDateTime *) 0 ;
26031 wxDateTime *arg2 = 0 ;
26032 wxTimeSpan *arg3 = 0 ;
26033 bool result;
26034 void *argp1 = 0 ;
26035 int res1 = 0 ;
26036 void *argp2 = 0 ;
26037 int res2 = 0 ;
26038 void *argp3 = 0 ;
26039 int res3 = 0 ;
26040 PyObject * obj0 = 0 ;
26041 PyObject * obj1 = 0 ;
26042 PyObject * obj2 = 0 ;
26043 char * kwnames[] = {
26044 (char *) "self",(char *) "dt",(char *) "ts", NULL
26045 };
26046
26047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26049 if (!SWIG_IsOK(res1)) {
26050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26051 }
26052 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26054 if (!SWIG_IsOK(res2)) {
26055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26056 }
26057 if (!argp2) {
26058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26059 }
26060 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26061 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26062 if (!SWIG_IsOK(res3)) {
26063 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26064 }
26065 if (!argp3) {
26066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26067 }
26068 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26072 wxPyEndAllowThreads(__tstate);
26073 if (PyErr_Occurred()) SWIG_fail;
26074 }
26075 {
26076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26077 }
26078 return resultobj;
26079 fail:
26080 return NULL;
26081 }
26082
26083
26084 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26085 PyObject *resultobj = 0;
26086 wxDateTime *arg1 = (wxDateTime *) 0 ;
26087 wxTimeSpan *arg2 = 0 ;
26088 wxDateTime *result = 0 ;
26089 void *argp1 = 0 ;
26090 int res1 = 0 ;
26091 void *argp2 = 0 ;
26092 int res2 = 0 ;
26093 PyObject * obj0 = 0 ;
26094 PyObject * obj1 = 0 ;
26095 char * kwnames[] = {
26096 (char *) "self",(char *) "diff", NULL
26097 };
26098
26099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
26100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26101 if (!SWIG_IsOK(res1)) {
26102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26103 }
26104 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26105 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26106 if (!SWIG_IsOK(res2)) {
26107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26108 }
26109 if (!argp2) {
26110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26111 }
26112 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26113 {
26114 PyThreadState* __tstate = wxPyBeginAllowThreads();
26115 {
26116 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
26117 result = (wxDateTime *) &_result_ref;
26118 }
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26130 PyObject *resultobj = 0;
26131 wxDateTime *arg1 = (wxDateTime *) 0 ;
26132 wxDateSpan *arg2 = 0 ;
26133 wxDateTime *result = 0 ;
26134 void *argp1 = 0 ;
26135 int res1 = 0 ;
26136 void *argp2 = 0 ;
26137 int res2 = 0 ;
26138 PyObject * obj0 = 0 ;
26139 PyObject * obj1 = 0 ;
26140 char * kwnames[] = {
26141 (char *) "self",(char *) "diff", NULL
26142 };
26143
26144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
26145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26146 if (!SWIG_IsOK(res1)) {
26147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26148 }
26149 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26151 if (!SWIG_IsOK(res2)) {
26152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26153 }
26154 if (!argp2) {
26155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26156 }
26157 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 {
26161 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26162 result = (wxDateTime *) &_result_ref;
26163 }
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26175 PyObject *resultobj = 0;
26176 wxDateTime *arg1 = (wxDateTime *) 0 ;
26177 wxTimeSpan *arg2 = 0 ;
26178 wxDateTime *result = 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 void *argp2 = 0 ;
26182 int res2 = 0 ;
26183 PyObject * obj0 = 0 ;
26184 PyObject * obj1 = 0 ;
26185 char * kwnames[] = {
26186 (char *) "self",(char *) "diff", NULL
26187 };
26188
26189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26191 if (!SWIG_IsOK(res1)) {
26192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26193 }
26194 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26196 if (!SWIG_IsOK(res2)) {
26197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26198 }
26199 if (!argp2) {
26200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26201 }
26202 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26203 {
26204 PyThreadState* __tstate = wxPyBeginAllowThreads();
26205 {
26206 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26207 result = (wxDateTime *) &_result_ref;
26208 }
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj = 0;
26221 wxDateTime *arg1 = (wxDateTime *) 0 ;
26222 wxDateSpan *arg2 = 0 ;
26223 wxDateTime *result = 0 ;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 void *argp2 = 0 ;
26227 int res2 = 0 ;
26228 PyObject * obj0 = 0 ;
26229 PyObject * obj1 = 0 ;
26230 char * kwnames[] = {
26231 (char *) "self",(char *) "diff", NULL
26232 };
26233
26234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26236 if (!SWIG_IsOK(res1)) {
26237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26238 }
26239 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26240 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26241 if (!SWIG_IsOK(res2)) {
26242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26243 }
26244 if (!argp2) {
26245 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26246 }
26247 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26248 {
26249 PyThreadState* __tstate = wxPyBeginAllowThreads();
26250 {
26251 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26252 result = (wxDateTime *) &_result_ref;
26253 }
26254 wxPyEndAllowThreads(__tstate);
26255 if (PyErr_Occurred()) SWIG_fail;
26256 }
26257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26258 return resultobj;
26259 fail:
26260 return NULL;
26261 }
26262
26263
26264 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26265 PyObject *resultobj = 0;
26266 wxDateTime *arg1 = (wxDateTime *) 0 ;
26267 wxDateTime *arg2 = 0 ;
26268 wxTimeSpan result;
26269 void *argp1 = 0 ;
26270 int res1 = 0 ;
26271 void *argp2 = 0 ;
26272 int res2 = 0 ;
26273 PyObject * obj0 = 0 ;
26274 PyObject * obj1 = 0 ;
26275 char * kwnames[] = {
26276 (char *) "self",(char *) "dt", NULL
26277 };
26278
26279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26281 if (!SWIG_IsOK(res1)) {
26282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26283 }
26284 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26285 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26286 if (!SWIG_IsOK(res2)) {
26287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26288 }
26289 if (!argp2) {
26290 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26291 }
26292 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26296 wxPyEndAllowThreads(__tstate);
26297 if (PyErr_Occurred()) SWIG_fail;
26298 }
26299 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26300 return resultobj;
26301 fail:
26302 return NULL;
26303 }
26304
26305
26306 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26307 PyObject *resultobj = 0;
26308 wxDateTime *arg1 = (wxDateTime *) 0 ;
26309 wxTimeSpan *arg2 = 0 ;
26310 wxDateTime *result = 0 ;
26311 void *argp1 = 0 ;
26312 int res1 = 0 ;
26313 void *argp2 = 0 ;
26314 int res2 = 0 ;
26315
26316 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26318 if (!SWIG_IsOK(res1)) {
26319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26320 }
26321 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26322 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26323 if (!SWIG_IsOK(res2)) {
26324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26325 }
26326 if (!argp2) {
26327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26328 }
26329 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26330 {
26331 PyThreadState* __tstate = wxPyBeginAllowThreads();
26332 {
26333 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26334 result = (wxDateTime *) &_result_ref;
26335 }
26336 wxPyEndAllowThreads(__tstate);
26337 if (PyErr_Occurred()) SWIG_fail;
26338 }
26339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26340 return resultobj;
26341 fail:
26342 return NULL;
26343 }
26344
26345
26346 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26347 PyObject *resultobj = 0;
26348 wxDateTime *arg1 = (wxDateTime *) 0 ;
26349 wxDateSpan *arg2 = 0 ;
26350 wxDateTime *result = 0 ;
26351 void *argp1 = 0 ;
26352 int res1 = 0 ;
26353 void *argp2 = 0 ;
26354 int res2 = 0 ;
26355
26356 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26360 }
26361 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26362 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26363 if (!SWIG_IsOK(res2)) {
26364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26365 }
26366 if (!argp2) {
26367 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26368 }
26369 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26370 {
26371 PyThreadState* __tstate = wxPyBeginAllowThreads();
26372 {
26373 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26374 result = (wxDateTime *) &_result_ref;
26375 }
26376 wxPyEndAllowThreads(__tstate);
26377 if (PyErr_Occurred()) SWIG_fail;
26378 }
26379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26380 return resultobj;
26381 fail:
26382 return NULL;
26383 }
26384
26385
26386 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26387 int argc;
26388 PyObject *argv[3];
26389
26390 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26391 --argc;
26392 if (argc == 2) {
26393 int _v = 0;
26394 {
26395 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26396 _v = SWIG_CheckState(res);
26397 }
26398 if (!_v) goto check_1;
26399 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26400 }
26401 check_1:
26402
26403 if (argc == 2) {
26404 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26405 }
26406
26407 fail:
26408 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26409 return NULL;
26410 }
26411
26412
26413 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26414 PyObject *resultobj = 0;
26415 wxDateTime *arg1 = (wxDateTime *) 0 ;
26416 wxTimeSpan *arg2 = 0 ;
26417 wxDateTime *result = 0 ;
26418 void *argp1 = 0 ;
26419 int res1 = 0 ;
26420 void *argp2 = 0 ;
26421 int res2 = 0 ;
26422
26423 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26425 if (!SWIG_IsOK(res1)) {
26426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26427 }
26428 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26429 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26430 if (!SWIG_IsOK(res2)) {
26431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26432 }
26433 if (!argp2) {
26434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26435 }
26436 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 {
26440 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26441 result = (wxDateTime *) &_result_ref;
26442 }
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26447 return resultobj;
26448 fail:
26449 return NULL;
26450 }
26451
26452
26453 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26454 PyObject *resultobj = 0;
26455 wxDateTime *arg1 = (wxDateTime *) 0 ;
26456 wxDateSpan *arg2 = 0 ;
26457 wxDateTime *result = 0 ;
26458 void *argp1 = 0 ;
26459 int res1 = 0 ;
26460 void *argp2 = 0 ;
26461 int res2 = 0 ;
26462
26463 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26465 if (!SWIG_IsOK(res1)) {
26466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26467 }
26468 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26469 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26470 if (!SWIG_IsOK(res2)) {
26471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26472 }
26473 if (!argp2) {
26474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26475 }
26476 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 {
26480 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26481 result = (wxDateTime *) &_result_ref;
26482 }
26483 wxPyEndAllowThreads(__tstate);
26484 if (PyErr_Occurred()) SWIG_fail;
26485 }
26486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26487 return resultobj;
26488 fail:
26489 return NULL;
26490 }
26491
26492
26493 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26494 int argc;
26495 PyObject *argv[3];
26496
26497 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26498 --argc;
26499 if (argc == 2) {
26500 int _v = 0;
26501 {
26502 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26503 _v = SWIG_CheckState(res);
26504 }
26505 if (!_v) goto check_1;
26506 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26507 }
26508 check_1:
26509
26510 if (argc == 2) {
26511 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26512 }
26513
26514 fail:
26515 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26516 return NULL;
26517 }
26518
26519
26520 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26521 PyObject *resultobj = 0;
26522 wxDateTime *arg1 = (wxDateTime *) 0 ;
26523 wxTimeSpan *arg2 = 0 ;
26524 wxDateTime result;
26525 void *argp1 = 0 ;
26526 int res1 = 0 ;
26527 void *argp2 = 0 ;
26528 int res2 = 0 ;
26529
26530 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26532 if (!SWIG_IsOK(res1)) {
26533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26534 }
26535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26536 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26537 if (!SWIG_IsOK(res2)) {
26538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26539 }
26540 if (!argp2) {
26541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26542 }
26543 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26544 {
26545 PyThreadState* __tstate = wxPyBeginAllowThreads();
26546 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26551 return resultobj;
26552 fail:
26553 return NULL;
26554 }
26555
26556
26557 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26558 PyObject *resultobj = 0;
26559 wxDateTime *arg1 = (wxDateTime *) 0 ;
26560 wxDateSpan *arg2 = 0 ;
26561 wxDateTime result;
26562 void *argp1 = 0 ;
26563 int res1 = 0 ;
26564 void *argp2 = 0 ;
26565 int res2 = 0 ;
26566
26567 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26569 if (!SWIG_IsOK(res1)) {
26570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26571 }
26572 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26573 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26574 if (!SWIG_IsOK(res2)) {
26575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26576 }
26577 if (!argp2) {
26578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26579 }
26580 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26581 {
26582 PyThreadState* __tstate = wxPyBeginAllowThreads();
26583 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26584 wxPyEndAllowThreads(__tstate);
26585 if (PyErr_Occurred()) SWIG_fail;
26586 }
26587 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26588 return resultobj;
26589 fail:
26590 return NULL;
26591 }
26592
26593
26594 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26595 int argc;
26596 PyObject *argv[3];
26597
26598 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26599 --argc;
26600 if (argc == 2) {
26601 int _v = 0;
26602 {
26603 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26604 _v = SWIG_CheckState(res);
26605 }
26606 if (!_v) goto check_1;
26607 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26608 }
26609 check_1:
26610
26611 if (argc == 2) {
26612 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26613 }
26614
26615 fail:
26616 Py_INCREF(Py_NotImplemented);
26617 return Py_NotImplemented;
26618 }
26619
26620
26621 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26622 PyObject *resultobj = 0;
26623 wxDateTime *arg1 = (wxDateTime *) 0 ;
26624 wxDateTime *arg2 = 0 ;
26625 wxTimeSpan result;
26626 void *argp1 = 0 ;
26627 int res1 = 0 ;
26628 void *argp2 = 0 ;
26629 int res2 = 0 ;
26630
26631 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26635 }
26636 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26637 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26638 if (!SWIG_IsOK(res2)) {
26639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26640 }
26641 if (!argp2) {
26642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26643 }
26644 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26645 {
26646 PyThreadState* __tstate = wxPyBeginAllowThreads();
26647 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26648 wxPyEndAllowThreads(__tstate);
26649 if (PyErr_Occurred()) SWIG_fail;
26650 }
26651 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26652 return resultobj;
26653 fail:
26654 return NULL;
26655 }
26656
26657
26658 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26659 PyObject *resultobj = 0;
26660 wxDateTime *arg1 = (wxDateTime *) 0 ;
26661 wxTimeSpan *arg2 = 0 ;
26662 wxDateTime result;
26663 void *argp1 = 0 ;
26664 int res1 = 0 ;
26665 void *argp2 = 0 ;
26666 int res2 = 0 ;
26667
26668 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26670 if (!SWIG_IsOK(res1)) {
26671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26672 }
26673 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26674 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26675 if (!SWIG_IsOK(res2)) {
26676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26677 }
26678 if (!argp2) {
26679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26680 }
26681 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26682 {
26683 PyThreadState* __tstate = wxPyBeginAllowThreads();
26684 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26685 wxPyEndAllowThreads(__tstate);
26686 if (PyErr_Occurred()) SWIG_fail;
26687 }
26688 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26689 return resultobj;
26690 fail:
26691 return NULL;
26692 }
26693
26694
26695 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26696 PyObject *resultobj = 0;
26697 wxDateTime *arg1 = (wxDateTime *) 0 ;
26698 wxDateSpan *arg2 = 0 ;
26699 wxDateTime result;
26700 void *argp1 = 0 ;
26701 int res1 = 0 ;
26702 void *argp2 = 0 ;
26703 int res2 = 0 ;
26704
26705 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26707 if (!SWIG_IsOK(res1)) {
26708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26709 }
26710 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26711 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26712 if (!SWIG_IsOK(res2)) {
26713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26714 }
26715 if (!argp2) {
26716 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26717 }
26718 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26722 wxPyEndAllowThreads(__tstate);
26723 if (PyErr_Occurred()) SWIG_fail;
26724 }
26725 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26726 return resultobj;
26727 fail:
26728 return NULL;
26729 }
26730
26731
26732 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26733 int argc;
26734 PyObject *argv[3];
26735
26736 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26737 --argc;
26738 if (argc == 2) {
26739 int _v = 0;
26740 {
26741 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26742 _v = SWIG_CheckState(res);
26743 }
26744 if (!_v) goto check_1;
26745 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26746 }
26747 check_1:
26748
26749 if (argc == 2) {
26750 int _v = 0;
26751 {
26752 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26753 _v = SWIG_CheckState(res);
26754 }
26755 if (!_v) goto check_2;
26756 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26757 }
26758 check_2:
26759
26760 if (argc == 2) {
26761 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26762 }
26763
26764 fail:
26765 Py_INCREF(Py_NotImplemented);
26766 return Py_NotImplemented;
26767 }
26768
26769
26770 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = 0;
26772 wxDateTime *arg1 = (wxDateTime *) 0 ;
26773 wxDateTime *arg2 = (wxDateTime *) 0 ;
26774 bool result;
26775 void *argp1 = 0 ;
26776 int res1 = 0 ;
26777 void *argp2 = 0 ;
26778 int res2 = 0 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char * kwnames[] = {
26782 (char *) "self",(char *) "other", NULL
26783 };
26784
26785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26787 if (!SWIG_IsOK(res1)) {
26788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26789 }
26790 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26792 if (!SWIG_IsOK(res2)) {
26793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26794 }
26795 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 {
26803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26804 }
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26812 PyObject *resultobj = 0;
26813 wxDateTime *arg1 = (wxDateTime *) 0 ;
26814 wxDateTime *arg2 = (wxDateTime *) 0 ;
26815 bool result;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 void *argp2 = 0 ;
26819 int res2 = 0 ;
26820 PyObject * obj0 = 0 ;
26821 PyObject * obj1 = 0 ;
26822 char * kwnames[] = {
26823 (char *) "self",(char *) "other", NULL
26824 };
26825
26826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26828 if (!SWIG_IsOK(res1)) {
26829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26830 }
26831 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26833 if (!SWIG_IsOK(res2)) {
26834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26835 }
26836 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26837 {
26838 PyThreadState* __tstate = wxPyBeginAllowThreads();
26839 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26840 wxPyEndAllowThreads(__tstate);
26841 if (PyErr_Occurred()) SWIG_fail;
26842 }
26843 {
26844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26845 }
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj = 0;
26854 wxDateTime *arg1 = (wxDateTime *) 0 ;
26855 wxDateTime *arg2 = (wxDateTime *) 0 ;
26856 bool result;
26857 void *argp1 = 0 ;
26858 int res1 = 0 ;
26859 void *argp2 = 0 ;
26860 int res2 = 0 ;
26861 PyObject * obj0 = 0 ;
26862 PyObject * obj1 = 0 ;
26863 char * kwnames[] = {
26864 (char *) "self",(char *) "other", NULL
26865 };
26866
26867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26869 if (!SWIG_IsOK(res1)) {
26870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26871 }
26872 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26874 if (!SWIG_IsOK(res2)) {
26875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26876 }
26877 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26881 wxPyEndAllowThreads(__tstate);
26882 if (PyErr_Occurred()) SWIG_fail;
26883 }
26884 {
26885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26886 }
26887 return resultobj;
26888 fail:
26889 return NULL;
26890 }
26891
26892
26893 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26894 PyObject *resultobj = 0;
26895 wxDateTime *arg1 = (wxDateTime *) 0 ;
26896 wxDateTime *arg2 = (wxDateTime *) 0 ;
26897 bool result;
26898 void *argp1 = 0 ;
26899 int res1 = 0 ;
26900 void *argp2 = 0 ;
26901 int res2 = 0 ;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 char * kwnames[] = {
26905 (char *) "self",(char *) "other", NULL
26906 };
26907
26908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26910 if (!SWIG_IsOK(res1)) {
26911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26912 }
26913 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26914 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26915 if (!SWIG_IsOK(res2)) {
26916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26917 }
26918 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26919 {
26920 PyThreadState* __tstate = wxPyBeginAllowThreads();
26921 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26922 wxPyEndAllowThreads(__tstate);
26923 if (PyErr_Occurred()) SWIG_fail;
26924 }
26925 {
26926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26927 }
26928 return resultobj;
26929 fail:
26930 return NULL;
26931 }
26932
26933
26934 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26935 PyObject *resultobj = 0;
26936 wxDateTime *arg1 = (wxDateTime *) 0 ;
26937 wxDateTime *arg2 = (wxDateTime *) 0 ;
26938 bool result;
26939 void *argp1 = 0 ;
26940 int res1 = 0 ;
26941 void *argp2 = 0 ;
26942 int res2 = 0 ;
26943 PyObject * obj0 = 0 ;
26944 PyObject * obj1 = 0 ;
26945 char * kwnames[] = {
26946 (char *) "self",(char *) "other", NULL
26947 };
26948
26949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26951 if (!SWIG_IsOK(res1)) {
26952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26953 }
26954 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26955 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26956 if (!SWIG_IsOK(res2)) {
26957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26958 }
26959 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 {
26967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26968 }
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26976 PyObject *resultobj = 0;
26977 wxDateTime *arg1 = (wxDateTime *) 0 ;
26978 wxDateTime *arg2 = (wxDateTime *) 0 ;
26979 bool result;
26980 void *argp1 = 0 ;
26981 int res1 = 0 ;
26982 void *argp2 = 0 ;
26983 int res2 = 0 ;
26984 PyObject * obj0 = 0 ;
26985 PyObject * obj1 = 0 ;
26986 char * kwnames[] = {
26987 (char *) "self",(char *) "other", NULL
26988 };
26989
26990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26992 if (!SWIG_IsOK(res1)) {
26993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26994 }
26995 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26997 if (!SWIG_IsOK(res2)) {
26998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26999 }
27000 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 {
27008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27009 }
27010 return resultobj;
27011 fail:
27012 return NULL;
27013 }
27014
27015
27016 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27017 PyObject *resultobj = 0;
27018 wxDateTime *arg1 = (wxDateTime *) 0 ;
27019 wxString *arg2 = 0 ;
27020 int result;
27021 void *argp1 = 0 ;
27022 int res1 = 0 ;
27023 bool temp2 = false ;
27024 PyObject * obj0 = 0 ;
27025 PyObject * obj1 = 0 ;
27026 char * kwnames[] = {
27027 (char *) "self",(char *) "date", NULL
27028 };
27029
27030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27032 if (!SWIG_IsOK(res1)) {
27033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27034 }
27035 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27036 {
27037 arg2 = wxString_in_helper(obj1);
27038 if (arg2 == NULL) SWIG_fail;
27039 temp2 = true;
27040 }
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 resultobj = SWIG_From_int(static_cast< int >(result));
27048 {
27049 if (temp2)
27050 delete arg2;
27051 }
27052 return resultobj;
27053 fail:
27054 {
27055 if (temp2)
27056 delete arg2;
27057 }
27058 return NULL;
27059 }
27060
27061
27062 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27063 PyObject *resultobj = 0;
27064 wxDateTime *arg1 = (wxDateTime *) 0 ;
27065 wxString *arg2 = 0 ;
27066 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27067 wxString *arg3 = (wxString *) &arg3_defvalue ;
27068 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27069 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27070 int result;
27071 void *argp1 = 0 ;
27072 int res1 = 0 ;
27073 bool temp2 = false ;
27074 bool temp3 = false ;
27075 void *argp4 = 0 ;
27076 int res4 = 0 ;
27077 PyObject * obj0 = 0 ;
27078 PyObject * obj1 = 0 ;
27079 PyObject * obj2 = 0 ;
27080 PyObject * obj3 = 0 ;
27081 char * kwnames[] = {
27082 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27083 };
27084
27085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27087 if (!SWIG_IsOK(res1)) {
27088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27089 }
27090 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27091 {
27092 arg2 = wxString_in_helper(obj1);
27093 if (arg2 == NULL) SWIG_fail;
27094 temp2 = true;
27095 }
27096 if (obj2) {
27097 {
27098 arg3 = wxString_in_helper(obj2);
27099 if (arg3 == NULL) SWIG_fail;
27100 temp3 = true;
27101 }
27102 }
27103 if (obj3) {
27104 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
27105 if (!SWIG_IsOK(res4)) {
27106 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27107 }
27108 if (!argp4) {
27109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27110 }
27111 arg4 = reinterpret_cast< wxDateTime * >(argp4);
27112 }
27113 {
27114 PyThreadState* __tstate = wxPyBeginAllowThreads();
27115 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 resultobj = SWIG_From_int(static_cast< int >(result));
27120 {
27121 if (temp2)
27122 delete arg2;
27123 }
27124 {
27125 if (temp3)
27126 delete arg3;
27127 }
27128 return resultobj;
27129 fail:
27130 {
27131 if (temp2)
27132 delete arg2;
27133 }
27134 {
27135 if (temp3)
27136 delete arg3;
27137 }
27138 return NULL;
27139 }
27140
27141
27142 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27143 PyObject *resultobj = 0;
27144 wxDateTime *arg1 = (wxDateTime *) 0 ;
27145 wxString *arg2 = 0 ;
27146 int result;
27147 void *argp1 = 0 ;
27148 int res1 = 0 ;
27149 bool temp2 = false ;
27150 PyObject * obj0 = 0 ;
27151 PyObject * obj1 = 0 ;
27152 char * kwnames[] = {
27153 (char *) "self",(char *) "datetime", NULL
27154 };
27155
27156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
27157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27158 if (!SWIG_IsOK(res1)) {
27159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27160 }
27161 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27162 {
27163 arg2 = wxString_in_helper(obj1);
27164 if (arg2 == NULL) SWIG_fail;
27165 temp2 = true;
27166 }
27167 {
27168 PyThreadState* __tstate = wxPyBeginAllowThreads();
27169 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
27170 wxPyEndAllowThreads(__tstate);
27171 if (PyErr_Occurred()) SWIG_fail;
27172 }
27173 resultobj = SWIG_From_int(static_cast< int >(result));
27174 {
27175 if (temp2)
27176 delete arg2;
27177 }
27178 return resultobj;
27179 fail:
27180 {
27181 if (temp2)
27182 delete arg2;
27183 }
27184 return NULL;
27185 }
27186
27187
27188 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27189 PyObject *resultobj = 0;
27190 wxDateTime *arg1 = (wxDateTime *) 0 ;
27191 wxString *arg2 = 0 ;
27192 int result;
27193 void *argp1 = 0 ;
27194 int res1 = 0 ;
27195 bool temp2 = false ;
27196 PyObject * obj0 = 0 ;
27197 PyObject * obj1 = 0 ;
27198 char * kwnames[] = {
27199 (char *) "self",(char *) "date", NULL
27200 };
27201
27202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27204 if (!SWIG_IsOK(res1)) {
27205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27206 }
27207 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27208 {
27209 arg2 = wxString_in_helper(obj1);
27210 if (arg2 == NULL) SWIG_fail;
27211 temp2 = true;
27212 }
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27216 wxPyEndAllowThreads(__tstate);
27217 if (PyErr_Occurred()) SWIG_fail;
27218 }
27219 resultobj = SWIG_From_int(static_cast< int >(result));
27220 {
27221 if (temp2)
27222 delete arg2;
27223 }
27224 return resultobj;
27225 fail:
27226 {
27227 if (temp2)
27228 delete arg2;
27229 }
27230 return NULL;
27231 }
27232
27233
27234 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27235 PyObject *resultobj = 0;
27236 wxDateTime *arg1 = (wxDateTime *) 0 ;
27237 wxString *arg2 = 0 ;
27238 int result;
27239 void *argp1 = 0 ;
27240 int res1 = 0 ;
27241 bool temp2 = false ;
27242 PyObject * obj0 = 0 ;
27243 PyObject * obj1 = 0 ;
27244 char * kwnames[] = {
27245 (char *) "self",(char *) "time", NULL
27246 };
27247
27248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27250 if (!SWIG_IsOK(res1)) {
27251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27252 }
27253 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27254 {
27255 arg2 = wxString_in_helper(obj1);
27256 if (arg2 == NULL) SWIG_fail;
27257 temp2 = true;
27258 }
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 resultobj = SWIG_From_int(static_cast< int >(result));
27266 {
27267 if (temp2)
27268 delete arg2;
27269 }
27270 return resultobj;
27271 fail:
27272 {
27273 if (temp2)
27274 delete arg2;
27275 }
27276 return NULL;
27277 }
27278
27279
27280 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27281 PyObject *resultobj = 0;
27282 wxDateTime *arg1 = (wxDateTime *) 0 ;
27283 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27284 wxString *arg2 = (wxString *) &arg2_defvalue ;
27285 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27286 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27287 wxString result;
27288 void *argp1 = 0 ;
27289 int res1 = 0 ;
27290 bool temp2 = false ;
27291 bool temp3 = false ;
27292 PyObject * obj0 = 0 ;
27293 PyObject * obj1 = 0 ;
27294 PyObject * obj2 = 0 ;
27295 char * kwnames[] = {
27296 (char *) "self",(char *) "format",(char *) "tz", NULL
27297 };
27298
27299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27301 if (!SWIG_IsOK(res1)) {
27302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27303 }
27304 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27305 if (obj1) {
27306 {
27307 arg2 = wxString_in_helper(obj1);
27308 if (arg2 == NULL) SWIG_fail;
27309 temp2 = true;
27310 }
27311 }
27312 if (obj2) {
27313 {
27314 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27315 temp3 = true;
27316 }
27317 }
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27321 wxPyEndAllowThreads(__tstate);
27322 if (PyErr_Occurred()) SWIG_fail;
27323 }
27324 {
27325 #if wxUSE_UNICODE
27326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27327 #else
27328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27329 #endif
27330 }
27331 {
27332 if (temp2)
27333 delete arg2;
27334 }
27335 {
27336 if (temp3) delete arg3;
27337 }
27338 return resultobj;
27339 fail:
27340 {
27341 if (temp2)
27342 delete arg2;
27343 }
27344 {
27345 if (temp3) delete arg3;
27346 }
27347 return NULL;
27348 }
27349
27350
27351 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27352 PyObject *resultobj = 0;
27353 wxDateTime *arg1 = (wxDateTime *) 0 ;
27354 wxString result;
27355 void *argp1 = 0 ;
27356 int res1 = 0 ;
27357 PyObject *swig_obj[1] ;
27358
27359 if (!args) SWIG_fail;
27360 swig_obj[0] = args;
27361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27362 if (!SWIG_IsOK(res1)) {
27363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27364 }
27365 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27366 {
27367 PyThreadState* __tstate = wxPyBeginAllowThreads();
27368 result = ((wxDateTime const *)arg1)->FormatDate();
27369 wxPyEndAllowThreads(__tstate);
27370 if (PyErr_Occurred()) SWIG_fail;
27371 }
27372 {
27373 #if wxUSE_UNICODE
27374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27375 #else
27376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27377 #endif
27378 }
27379 return resultobj;
27380 fail:
27381 return NULL;
27382 }
27383
27384
27385 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27386 PyObject *resultobj = 0;
27387 wxDateTime *arg1 = (wxDateTime *) 0 ;
27388 wxString result;
27389 void *argp1 = 0 ;
27390 int res1 = 0 ;
27391 PyObject *swig_obj[1] ;
27392
27393 if (!args) SWIG_fail;
27394 swig_obj[0] = args;
27395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27396 if (!SWIG_IsOK(res1)) {
27397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27398 }
27399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27400 {
27401 PyThreadState* __tstate = wxPyBeginAllowThreads();
27402 result = ((wxDateTime const *)arg1)->FormatTime();
27403 wxPyEndAllowThreads(__tstate);
27404 if (PyErr_Occurred()) SWIG_fail;
27405 }
27406 {
27407 #if wxUSE_UNICODE
27408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27409 #else
27410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27411 #endif
27412 }
27413 return resultobj;
27414 fail:
27415 return NULL;
27416 }
27417
27418
27419 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27420 PyObject *resultobj = 0;
27421 wxDateTime *arg1 = (wxDateTime *) 0 ;
27422 wxString result;
27423 void *argp1 = 0 ;
27424 int res1 = 0 ;
27425 PyObject *swig_obj[1] ;
27426
27427 if (!args) SWIG_fail;
27428 swig_obj[0] = args;
27429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27430 if (!SWIG_IsOK(res1)) {
27431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27432 }
27433 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 result = ((wxDateTime const *)arg1)->FormatISODate();
27437 wxPyEndAllowThreads(__tstate);
27438 if (PyErr_Occurred()) SWIG_fail;
27439 }
27440 {
27441 #if wxUSE_UNICODE
27442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27443 #else
27444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27445 #endif
27446 }
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27454 PyObject *resultobj = 0;
27455 wxDateTime *arg1 = (wxDateTime *) 0 ;
27456 wxString result;
27457 void *argp1 = 0 ;
27458 int res1 = 0 ;
27459 PyObject *swig_obj[1] ;
27460
27461 if (!args) SWIG_fail;
27462 swig_obj[0] = args;
27463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27466 }
27467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 result = ((wxDateTime const *)arg1)->FormatISOTime();
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 {
27475 #if wxUSE_UNICODE
27476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27477 #else
27478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27479 #endif
27480 }
27481 return resultobj;
27482 fail:
27483 return NULL;
27484 }
27485
27486
27487 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27488 PyObject *obj;
27489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27490 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27491 return SWIG_Py_Void();
27492 }
27493
27494 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27495 return SWIG_Python_InitShadowInstance(args);
27496 }
27497
27498 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27499 PyObject *resultobj = 0;
27500 long arg1 ;
27501 wxTimeSpan result;
27502 long val1 ;
27503 int ecode1 = 0 ;
27504 PyObject * obj0 = 0 ;
27505 char * kwnames[] = {
27506 (char *) "ms", NULL
27507 };
27508
27509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27510 ecode1 = SWIG_AsVal_long(obj0, &val1);
27511 if (!SWIG_IsOK(ecode1)) {
27512 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27513 }
27514 arg1 = static_cast< long >(val1);
27515 {
27516 PyThreadState* __tstate = wxPyBeginAllowThreads();
27517 result = wxTimeSpan::Milliseconds(arg1);
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27529 PyObject *resultobj = 0;
27530 wxTimeSpan result;
27531
27532 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27533 {
27534 PyThreadState* __tstate = wxPyBeginAllowThreads();
27535 result = wxTimeSpan::Millisecond();
27536 wxPyEndAllowThreads(__tstate);
27537 if (PyErr_Occurred()) SWIG_fail;
27538 }
27539 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27540 return resultobj;
27541 fail:
27542 return NULL;
27543 }
27544
27545
27546 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27547 PyObject *resultobj = 0;
27548 long arg1 ;
27549 wxTimeSpan result;
27550 long val1 ;
27551 int ecode1 = 0 ;
27552 PyObject * obj0 = 0 ;
27553 char * kwnames[] = {
27554 (char *) "sec", NULL
27555 };
27556
27557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27558 ecode1 = SWIG_AsVal_long(obj0, &val1);
27559 if (!SWIG_IsOK(ecode1)) {
27560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27561 }
27562 arg1 = static_cast< long >(val1);
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 result = wxTimeSpan::Seconds(arg1);
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27570 return resultobj;
27571 fail:
27572 return NULL;
27573 }
27574
27575
27576 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27577 PyObject *resultobj = 0;
27578 wxTimeSpan result;
27579
27580 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 result = wxTimeSpan::Second();
27584 wxPyEndAllowThreads(__tstate);
27585 if (PyErr_Occurred()) SWIG_fail;
27586 }
27587 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27588 return resultobj;
27589 fail:
27590 return NULL;
27591 }
27592
27593
27594 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27595 PyObject *resultobj = 0;
27596 long arg1 ;
27597 wxTimeSpan result;
27598 long val1 ;
27599 int ecode1 = 0 ;
27600 PyObject * obj0 = 0 ;
27601 char * kwnames[] = {
27602 (char *) "min", NULL
27603 };
27604
27605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27606 ecode1 = SWIG_AsVal_long(obj0, &val1);
27607 if (!SWIG_IsOK(ecode1)) {
27608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27609 }
27610 arg1 = static_cast< long >(val1);
27611 {
27612 PyThreadState* __tstate = wxPyBeginAllowThreads();
27613 result = wxTimeSpan::Minutes(arg1);
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27618 return resultobj;
27619 fail:
27620 return NULL;
27621 }
27622
27623
27624 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27625 PyObject *resultobj = 0;
27626 wxTimeSpan result;
27627
27628 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 result = wxTimeSpan::Minute();
27632 wxPyEndAllowThreads(__tstate);
27633 if (PyErr_Occurred()) SWIG_fail;
27634 }
27635 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27636 return resultobj;
27637 fail:
27638 return NULL;
27639 }
27640
27641
27642 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27643 PyObject *resultobj = 0;
27644 long arg1 ;
27645 wxTimeSpan result;
27646 long val1 ;
27647 int ecode1 = 0 ;
27648 PyObject * obj0 = 0 ;
27649 char * kwnames[] = {
27650 (char *) "hours", NULL
27651 };
27652
27653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27654 ecode1 = SWIG_AsVal_long(obj0, &val1);
27655 if (!SWIG_IsOK(ecode1)) {
27656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27657 }
27658 arg1 = static_cast< long >(val1);
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 result = wxTimeSpan::Hours(arg1);
27662 wxPyEndAllowThreads(__tstate);
27663 if (PyErr_Occurred()) SWIG_fail;
27664 }
27665 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27666 return resultobj;
27667 fail:
27668 return NULL;
27669 }
27670
27671
27672 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27673 PyObject *resultobj = 0;
27674 wxTimeSpan result;
27675
27676 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = wxTimeSpan::Hour();
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27684 return resultobj;
27685 fail:
27686 return NULL;
27687 }
27688
27689
27690 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27691 PyObject *resultobj = 0;
27692 long arg1 ;
27693 wxTimeSpan result;
27694 long val1 ;
27695 int ecode1 = 0 ;
27696 PyObject * obj0 = 0 ;
27697 char * kwnames[] = {
27698 (char *) "days", NULL
27699 };
27700
27701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27702 ecode1 = SWIG_AsVal_long(obj0, &val1);
27703 if (!SWIG_IsOK(ecode1)) {
27704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27705 }
27706 arg1 = static_cast< long >(val1);
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 result = wxTimeSpan::Days(arg1);
27710 wxPyEndAllowThreads(__tstate);
27711 if (PyErr_Occurred()) SWIG_fail;
27712 }
27713 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27714 return resultobj;
27715 fail:
27716 return NULL;
27717 }
27718
27719
27720 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27721 PyObject *resultobj = 0;
27722 wxTimeSpan result;
27723
27724 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 result = wxTimeSpan::Day();
27728 wxPyEndAllowThreads(__tstate);
27729 if (PyErr_Occurred()) SWIG_fail;
27730 }
27731 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27739 PyObject *resultobj = 0;
27740 long arg1 ;
27741 wxTimeSpan result;
27742 long val1 ;
27743 int ecode1 = 0 ;
27744 PyObject * obj0 = 0 ;
27745 char * kwnames[] = {
27746 (char *) "days", NULL
27747 };
27748
27749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27750 ecode1 = SWIG_AsVal_long(obj0, &val1);
27751 if (!SWIG_IsOK(ecode1)) {
27752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27753 }
27754 arg1 = static_cast< long >(val1);
27755 {
27756 PyThreadState* __tstate = wxPyBeginAllowThreads();
27757 result = wxTimeSpan::Weeks(arg1);
27758 wxPyEndAllowThreads(__tstate);
27759 if (PyErr_Occurred()) SWIG_fail;
27760 }
27761 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27762 return resultobj;
27763 fail:
27764 return NULL;
27765 }
27766
27767
27768 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27769 PyObject *resultobj = 0;
27770 wxTimeSpan result;
27771
27772 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27773 {
27774 PyThreadState* __tstate = wxPyBeginAllowThreads();
27775 result = wxTimeSpan::Week();
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27787 PyObject *resultobj = 0;
27788 long arg1 = (long) 0 ;
27789 long arg2 = (long) 0 ;
27790 long arg3 = (long) 0 ;
27791 long arg4 = (long) 0 ;
27792 wxTimeSpan *result = 0 ;
27793 long val1 ;
27794 int ecode1 = 0 ;
27795 long val2 ;
27796 int ecode2 = 0 ;
27797 long val3 ;
27798 int ecode3 = 0 ;
27799 long val4 ;
27800 int ecode4 = 0 ;
27801 PyObject * obj0 = 0 ;
27802 PyObject * obj1 = 0 ;
27803 PyObject * obj2 = 0 ;
27804 PyObject * obj3 = 0 ;
27805 char * kwnames[] = {
27806 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27807 };
27808
27809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27810 if (obj0) {
27811 ecode1 = SWIG_AsVal_long(obj0, &val1);
27812 if (!SWIG_IsOK(ecode1)) {
27813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27814 }
27815 arg1 = static_cast< long >(val1);
27816 }
27817 if (obj1) {
27818 ecode2 = SWIG_AsVal_long(obj1, &val2);
27819 if (!SWIG_IsOK(ecode2)) {
27820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27821 }
27822 arg2 = static_cast< long >(val2);
27823 }
27824 if (obj2) {
27825 ecode3 = SWIG_AsVal_long(obj2, &val3);
27826 if (!SWIG_IsOK(ecode3)) {
27827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27828 }
27829 arg3 = static_cast< long >(val3);
27830 }
27831 if (obj3) {
27832 ecode4 = SWIG_AsVal_long(obj3, &val4);
27833 if (!SWIG_IsOK(ecode4)) {
27834 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27835 }
27836 arg4 = static_cast< long >(val4);
27837 }
27838 {
27839 PyThreadState* __tstate = wxPyBeginAllowThreads();
27840 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27841 wxPyEndAllowThreads(__tstate);
27842 if (PyErr_Occurred()) SWIG_fail;
27843 }
27844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27845 return resultobj;
27846 fail:
27847 return NULL;
27848 }
27849
27850
27851 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27852 PyObject *resultobj = 0;
27853 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27854 void *argp1 = 0 ;
27855 int res1 = 0 ;
27856 PyObject *swig_obj[1] ;
27857
27858 if (!args) SWIG_fail;
27859 swig_obj[0] = args;
27860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27861 if (!SWIG_IsOK(res1)) {
27862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27863 }
27864 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27865 {
27866 PyThreadState* __tstate = wxPyBeginAllowThreads();
27867 delete arg1;
27868
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 resultobj = SWIG_Py_Void();
27873 return resultobj;
27874 fail:
27875 return NULL;
27876 }
27877
27878
27879 SWIGINTERN PyObject *_wrap_TimeSpan_Add(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_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', 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_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27903 }
27904 if (!argp2) {
27905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', 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)->Add((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, 0 | 0 );
27918 return resultobj;
27919 fail:
27920 return NULL;
27921 }
27922
27923
27924 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27925 PyObject *resultobj = 0;
27926 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27927 wxTimeSpan *arg2 = 0 ;
27928 wxTimeSpan *result = 0 ;
27929 void *argp1 = 0 ;
27930 int res1 = 0 ;
27931 void *argp2 = 0 ;
27932 int res2 = 0 ;
27933 PyObject * obj0 = 0 ;
27934 PyObject * obj1 = 0 ;
27935 char * kwnames[] = {
27936 (char *) "self",(char *) "diff", NULL
27937 };
27938
27939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27941 if (!SWIG_IsOK(res1)) {
27942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27943 }
27944 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27946 if (!SWIG_IsOK(res2)) {
27947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27948 }
27949 if (!argp2) {
27950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27951 }
27952 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27953 {
27954 PyThreadState* __tstate = wxPyBeginAllowThreads();
27955 {
27956 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27957 result = (wxTimeSpan *) &_result_ref;
27958 }
27959 wxPyEndAllowThreads(__tstate);
27960 if (PyErr_Occurred()) SWIG_fail;
27961 }
27962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27963 return resultobj;
27964 fail:
27965 return NULL;
27966 }
27967
27968
27969 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27970 PyObject *resultobj = 0;
27971 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27972 int arg2 ;
27973 wxTimeSpan *result = 0 ;
27974 void *argp1 = 0 ;
27975 int res1 = 0 ;
27976 int val2 ;
27977 int ecode2 = 0 ;
27978 PyObject * obj0 = 0 ;
27979 PyObject * obj1 = 0 ;
27980 char * kwnames[] = {
27981 (char *) "self",(char *) "n", NULL
27982 };
27983
27984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27986 if (!SWIG_IsOK(res1)) {
27987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27988 }
27989 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27990 ecode2 = SWIG_AsVal_int(obj1, &val2);
27991 if (!SWIG_IsOK(ecode2)) {
27992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27993 }
27994 arg2 = static_cast< int >(val2);
27995 {
27996 PyThreadState* __tstate = wxPyBeginAllowThreads();
27997 {
27998 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27999 result = (wxTimeSpan *) &_result_ref;
28000 }
28001 wxPyEndAllowThreads(__tstate);
28002 if (PyErr_Occurred()) SWIG_fail;
28003 }
28004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28005 return resultobj;
28006 fail:
28007 return NULL;
28008 }
28009
28010
28011 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28012 PyObject *resultobj = 0;
28013 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28014 wxTimeSpan *result = 0 ;
28015 void *argp1 = 0 ;
28016 int res1 = 0 ;
28017 PyObject *swig_obj[1] ;
28018
28019 if (!args) SWIG_fail;
28020 swig_obj[0] = args;
28021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28022 if (!SWIG_IsOK(res1)) {
28023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28024 }
28025 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 {
28029 wxTimeSpan &_result_ref = (arg1)->Neg();
28030 result = (wxTimeSpan *) &_result_ref;
28031 }
28032 wxPyEndAllowThreads(__tstate);
28033 if (PyErr_Occurred()) SWIG_fail;
28034 }
28035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28036 return resultobj;
28037 fail:
28038 return NULL;
28039 }
28040
28041
28042 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28043 PyObject *resultobj = 0;
28044 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28045 wxTimeSpan result;
28046 void *argp1 = 0 ;
28047 int res1 = 0 ;
28048 PyObject *swig_obj[1] ;
28049
28050 if (!args) SWIG_fail;
28051 swig_obj[0] = args;
28052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28053 if (!SWIG_IsOK(res1)) {
28054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28055 }
28056 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28057 {
28058 PyThreadState* __tstate = wxPyBeginAllowThreads();
28059 result = ((wxTimeSpan const *)arg1)->Abs();
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28064 return resultobj;
28065 fail:
28066 return NULL;
28067 }
28068
28069
28070 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28071 PyObject *resultobj = 0;
28072 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28073 wxTimeSpan *arg2 = 0 ;
28074 wxTimeSpan *result = 0 ;
28075 void *argp1 = 0 ;
28076 int res1 = 0 ;
28077 void *argp2 = 0 ;
28078 int res2 = 0 ;
28079 PyObject * obj0 = 0 ;
28080 PyObject * obj1 = 0 ;
28081 char * kwnames[] = {
28082 (char *) "self",(char *) "diff", NULL
28083 };
28084
28085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28087 if (!SWIG_IsOK(res1)) {
28088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28089 }
28090 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28091 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28092 if (!SWIG_IsOK(res2)) {
28093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28094 }
28095 if (!argp2) {
28096 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28097 }
28098 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 {
28102 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
28103 result = (wxTimeSpan *) &_result_ref;
28104 }
28105 wxPyEndAllowThreads(__tstate);
28106 if (PyErr_Occurred()) SWIG_fail;
28107 }
28108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28109 return resultobj;
28110 fail:
28111 return NULL;
28112 }
28113
28114
28115 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28116 PyObject *resultobj = 0;
28117 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28118 wxTimeSpan *arg2 = 0 ;
28119 wxTimeSpan *result = 0 ;
28120 void *argp1 = 0 ;
28121 int res1 = 0 ;
28122 void *argp2 = 0 ;
28123 int res2 = 0 ;
28124 PyObject * obj0 = 0 ;
28125 PyObject * obj1 = 0 ;
28126 char * kwnames[] = {
28127 (char *) "self",(char *) "diff", NULL
28128 };
28129
28130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
28131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28132 if (!SWIG_IsOK(res1)) {
28133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28134 }
28135 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28136 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28137 if (!SWIG_IsOK(res2)) {
28138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28139 }
28140 if (!argp2) {
28141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28142 }
28143 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28144 {
28145 PyThreadState* __tstate = wxPyBeginAllowThreads();
28146 {
28147 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
28148 result = (wxTimeSpan *) &_result_ref;
28149 }
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28154 return resultobj;
28155 fail:
28156 return NULL;
28157 }
28158
28159
28160 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28161 PyObject *resultobj = 0;
28162 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28163 int arg2 ;
28164 wxTimeSpan *result = 0 ;
28165 void *argp1 = 0 ;
28166 int res1 = 0 ;
28167 int val2 ;
28168 int ecode2 = 0 ;
28169 PyObject * obj0 = 0 ;
28170 PyObject * obj1 = 0 ;
28171 char * kwnames[] = {
28172 (char *) "self",(char *) "n", NULL
28173 };
28174
28175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28177 if (!SWIG_IsOK(res1)) {
28178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28179 }
28180 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28181 ecode2 = SWIG_AsVal_int(obj1, &val2);
28182 if (!SWIG_IsOK(ecode2)) {
28183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28184 }
28185 arg2 = static_cast< int >(val2);
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 {
28189 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28190 result = (wxTimeSpan *) &_result_ref;
28191 }
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28203 PyObject *resultobj = 0;
28204 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28205 wxTimeSpan *result = 0 ;
28206 void *argp1 = 0 ;
28207 int res1 = 0 ;
28208 PyObject *swig_obj[1] ;
28209
28210 if (!args) SWIG_fail;
28211 swig_obj[0] = args;
28212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28213 if (!SWIG_IsOK(res1)) {
28214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28215 }
28216 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28217 {
28218 PyThreadState* __tstate = wxPyBeginAllowThreads();
28219 {
28220 wxTimeSpan &_result_ref = (arg1)->operator -();
28221 result = (wxTimeSpan *) &_result_ref;
28222 }
28223 wxPyEndAllowThreads(__tstate);
28224 if (PyErr_Occurred()) SWIG_fail;
28225 }
28226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28227 return resultobj;
28228 fail:
28229 return NULL;
28230 }
28231
28232
28233 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28234 PyObject *resultobj = 0;
28235 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28236 wxTimeSpan *arg2 = 0 ;
28237 wxTimeSpan result;
28238 void *argp1 = 0 ;
28239 int res1 = 0 ;
28240 void *argp2 = 0 ;
28241 int res2 = 0 ;
28242 PyObject * obj0 = 0 ;
28243 PyObject * obj1 = 0 ;
28244 char * kwnames[] = {
28245 (char *) "self",(char *) "other", NULL
28246 };
28247
28248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28250 if (!SWIG_IsOK(res1)) {
28251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28252 }
28253 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28254 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28255 if (!SWIG_IsOK(res2)) {
28256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28257 }
28258 if (!argp2) {
28259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28260 }
28261 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj = 0;
28277 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28278 wxTimeSpan *arg2 = 0 ;
28279 wxTimeSpan result;
28280 void *argp1 = 0 ;
28281 int res1 = 0 ;
28282 void *argp2 = 0 ;
28283 int res2 = 0 ;
28284 PyObject * obj0 = 0 ;
28285 PyObject * obj1 = 0 ;
28286 char * kwnames[] = {
28287 (char *) "self",(char *) "other", NULL
28288 };
28289
28290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28292 if (!SWIG_IsOK(res1)) {
28293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28294 }
28295 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28297 if (!SWIG_IsOK(res2)) {
28298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28299 }
28300 if (!argp2) {
28301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28302 }
28303 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28304 {
28305 PyThreadState* __tstate = wxPyBeginAllowThreads();
28306 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28307 wxPyEndAllowThreads(__tstate);
28308 if (PyErr_Occurred()) SWIG_fail;
28309 }
28310 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28311 return resultobj;
28312 fail:
28313 return NULL;
28314 }
28315
28316
28317 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28318 PyObject *resultobj = 0;
28319 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28320 int arg2 ;
28321 wxTimeSpan result;
28322 void *argp1 = 0 ;
28323 int res1 = 0 ;
28324 int val2 ;
28325 int ecode2 = 0 ;
28326 PyObject * obj0 = 0 ;
28327 PyObject * obj1 = 0 ;
28328 char * kwnames[] = {
28329 (char *) "self",(char *) "n", NULL
28330 };
28331
28332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28334 if (!SWIG_IsOK(res1)) {
28335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28336 }
28337 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28338 ecode2 = SWIG_AsVal_int(obj1, &val2);
28339 if (!SWIG_IsOK(ecode2)) {
28340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28341 }
28342 arg2 = static_cast< int >(val2);
28343 {
28344 PyThreadState* __tstate = wxPyBeginAllowThreads();
28345 result = wxTimeSpan___mul__(arg1,arg2);
28346 wxPyEndAllowThreads(__tstate);
28347 if (PyErr_Occurred()) SWIG_fail;
28348 }
28349 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28350 return resultobj;
28351 fail:
28352 return NULL;
28353 }
28354
28355
28356 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28357 PyObject *resultobj = 0;
28358 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28359 int arg2 ;
28360 wxTimeSpan result;
28361 void *argp1 = 0 ;
28362 int res1 = 0 ;
28363 int val2 ;
28364 int ecode2 = 0 ;
28365 PyObject * obj0 = 0 ;
28366 PyObject * obj1 = 0 ;
28367 char * kwnames[] = {
28368 (char *) "self",(char *) "n", NULL
28369 };
28370
28371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28373 if (!SWIG_IsOK(res1)) {
28374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28375 }
28376 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28377 ecode2 = SWIG_AsVal_int(obj1, &val2);
28378 if (!SWIG_IsOK(ecode2)) {
28379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28380 }
28381 arg2 = static_cast< int >(val2);
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = wxTimeSpan___rmul__(arg1,arg2);
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28389 return resultobj;
28390 fail:
28391 return NULL;
28392 }
28393
28394
28395 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28396 PyObject *resultobj = 0;
28397 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28398 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28399 bool result;
28400 void *argp1 = 0 ;
28401 int res1 = 0 ;
28402 void *argp2 = 0 ;
28403 int res2 = 0 ;
28404 PyObject * obj0 = 0 ;
28405 PyObject * obj1 = 0 ;
28406 char * kwnames[] = {
28407 (char *) "self",(char *) "other", NULL
28408 };
28409
28410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28412 if (!SWIG_IsOK(res1)) {
28413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28414 }
28415 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28417 if (!SWIG_IsOK(res2)) {
28418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28419 }
28420 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 {
28428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28429 }
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28437 PyObject *resultobj = 0;
28438 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28439 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28440 bool result;
28441 void *argp1 = 0 ;
28442 int res1 = 0 ;
28443 void *argp2 = 0 ;
28444 int res2 = 0 ;
28445 PyObject * obj0 = 0 ;
28446 PyObject * obj1 = 0 ;
28447 char * kwnames[] = {
28448 (char *) "self",(char *) "other", NULL
28449 };
28450
28451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28453 if (!SWIG_IsOK(res1)) {
28454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28455 }
28456 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28458 if (!SWIG_IsOK(res2)) {
28459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28460 }
28461 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 {
28469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28470 }
28471 return resultobj;
28472 fail:
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28478 PyObject *resultobj = 0;
28479 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28480 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28481 bool result;
28482 void *argp1 = 0 ;
28483 int res1 = 0 ;
28484 void *argp2 = 0 ;
28485 int res2 = 0 ;
28486 PyObject * obj0 = 0 ;
28487 PyObject * obj1 = 0 ;
28488 char * kwnames[] = {
28489 (char *) "self",(char *) "other", NULL
28490 };
28491
28492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28494 if (!SWIG_IsOK(res1)) {
28495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28496 }
28497 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28499 if (!SWIG_IsOK(res2)) {
28500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28501 }
28502 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28506 wxPyEndAllowThreads(__tstate);
28507 if (PyErr_Occurred()) SWIG_fail;
28508 }
28509 {
28510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28511 }
28512 return resultobj;
28513 fail:
28514 return NULL;
28515 }
28516
28517
28518 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28519 PyObject *resultobj = 0;
28520 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28521 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28522 bool result;
28523 void *argp1 = 0 ;
28524 int res1 = 0 ;
28525 void *argp2 = 0 ;
28526 int res2 = 0 ;
28527 PyObject * obj0 = 0 ;
28528 PyObject * obj1 = 0 ;
28529 char * kwnames[] = {
28530 (char *) "self",(char *) "other", NULL
28531 };
28532
28533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28535 if (!SWIG_IsOK(res1)) {
28536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28537 }
28538 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28540 if (!SWIG_IsOK(res2)) {
28541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28542 }
28543 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28544 {
28545 PyThreadState* __tstate = wxPyBeginAllowThreads();
28546 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28547 wxPyEndAllowThreads(__tstate);
28548 if (PyErr_Occurred()) SWIG_fail;
28549 }
28550 {
28551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28552 }
28553 return resultobj;
28554 fail:
28555 return NULL;
28556 }
28557
28558
28559 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28560 PyObject *resultobj = 0;
28561 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28562 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28563 bool result;
28564 void *argp1 = 0 ;
28565 int res1 = 0 ;
28566 void *argp2 = 0 ;
28567 int res2 = 0 ;
28568 PyObject * obj0 = 0 ;
28569 PyObject * obj1 = 0 ;
28570 char * kwnames[] = {
28571 (char *) "self",(char *) "other", NULL
28572 };
28573
28574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28576 if (!SWIG_IsOK(res1)) {
28577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28578 }
28579 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28580 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28581 if (!SWIG_IsOK(res2)) {
28582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28583 }
28584 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 {
28592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28593 }
28594 return resultobj;
28595 fail:
28596 return NULL;
28597 }
28598
28599
28600 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28601 PyObject *resultobj = 0;
28602 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28603 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28604 bool result;
28605 void *argp1 = 0 ;
28606 int res1 = 0 ;
28607 void *argp2 = 0 ;
28608 int res2 = 0 ;
28609 PyObject * obj0 = 0 ;
28610 PyObject * obj1 = 0 ;
28611 char * kwnames[] = {
28612 (char *) "self",(char *) "other", NULL
28613 };
28614
28615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28617 if (!SWIG_IsOK(res1)) {
28618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28619 }
28620 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28622 if (!SWIG_IsOK(res2)) {
28623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28624 }
28625 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 {
28633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28634 }
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28642 PyObject *resultobj = 0;
28643 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28644 bool result;
28645 void *argp1 = 0 ;
28646 int res1 = 0 ;
28647 PyObject *swig_obj[1] ;
28648
28649 if (!args) SWIG_fail;
28650 swig_obj[0] = args;
28651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28652 if (!SWIG_IsOK(res1)) {
28653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28654 }
28655 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28656 {
28657 PyThreadState* __tstate = wxPyBeginAllowThreads();
28658 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28659 wxPyEndAllowThreads(__tstate);
28660 if (PyErr_Occurred()) SWIG_fail;
28661 }
28662 {
28663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28664 }
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28672 PyObject *resultobj = 0;
28673 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28674 bool result;
28675 void *argp1 = 0 ;
28676 int res1 = 0 ;
28677 PyObject *swig_obj[1] ;
28678
28679 if (!args) SWIG_fail;
28680 swig_obj[0] = args;
28681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28682 if (!SWIG_IsOK(res1)) {
28683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28684 }
28685 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 {
28693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28694 }
28695 return resultobj;
28696 fail:
28697 return NULL;
28698 }
28699
28700
28701 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28702 PyObject *resultobj = 0;
28703 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28704 bool result;
28705 void *argp1 = 0 ;
28706 int res1 = 0 ;
28707 PyObject *swig_obj[1] ;
28708
28709 if (!args) SWIG_fail;
28710 swig_obj[0] = args;
28711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28712 if (!SWIG_IsOK(res1)) {
28713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28714 }
28715 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28716 {
28717 PyThreadState* __tstate = wxPyBeginAllowThreads();
28718 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 {
28723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28724 }
28725 return resultobj;
28726 fail:
28727 return NULL;
28728 }
28729
28730
28731 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28732 PyObject *resultobj = 0;
28733 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28734 wxTimeSpan *arg2 = 0 ;
28735 bool result;
28736 void *argp1 = 0 ;
28737 int res1 = 0 ;
28738 void *argp2 = 0 ;
28739 int res2 = 0 ;
28740 PyObject * obj0 = 0 ;
28741 PyObject * obj1 = 0 ;
28742 char * kwnames[] = {
28743 (char *) "self",(char *) "ts", NULL
28744 };
28745
28746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28748 if (!SWIG_IsOK(res1)) {
28749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28750 }
28751 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28753 if (!SWIG_IsOK(res2)) {
28754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28755 }
28756 if (!argp2) {
28757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28758 }
28759 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28760 {
28761 PyThreadState* __tstate = wxPyBeginAllowThreads();
28762 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28763 wxPyEndAllowThreads(__tstate);
28764 if (PyErr_Occurred()) SWIG_fail;
28765 }
28766 {
28767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28768 }
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28776 PyObject *resultobj = 0;
28777 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28778 wxTimeSpan *arg2 = 0 ;
28779 bool result;
28780 void *argp1 = 0 ;
28781 int res1 = 0 ;
28782 void *argp2 = 0 ;
28783 int res2 = 0 ;
28784 PyObject * obj0 = 0 ;
28785 PyObject * obj1 = 0 ;
28786 char * kwnames[] = {
28787 (char *) "self",(char *) "ts", NULL
28788 };
28789
28790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28792 if (!SWIG_IsOK(res1)) {
28793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28794 }
28795 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28797 if (!SWIG_IsOK(res2)) {
28798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28799 }
28800 if (!argp2) {
28801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28802 }
28803 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28804 {
28805 PyThreadState* __tstate = wxPyBeginAllowThreads();
28806 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28807 wxPyEndAllowThreads(__tstate);
28808 if (PyErr_Occurred()) SWIG_fail;
28809 }
28810 {
28811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28812 }
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28820 PyObject *resultobj = 0;
28821 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28822 wxTimeSpan *arg2 = 0 ;
28823 bool result;
28824 void *argp1 = 0 ;
28825 int res1 = 0 ;
28826 void *argp2 = 0 ;
28827 int res2 = 0 ;
28828 PyObject * obj0 = 0 ;
28829 PyObject * obj1 = 0 ;
28830 char * kwnames[] = {
28831 (char *) "self",(char *) "t", NULL
28832 };
28833
28834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28836 if (!SWIG_IsOK(res1)) {
28837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28838 }
28839 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28841 if (!SWIG_IsOK(res2)) {
28842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28843 }
28844 if (!argp2) {
28845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28846 }
28847 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28848 {
28849 PyThreadState* __tstate = wxPyBeginAllowThreads();
28850 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28851 wxPyEndAllowThreads(__tstate);
28852 if (PyErr_Occurred()) SWIG_fail;
28853 }
28854 {
28855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28856 }
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28864 PyObject *resultobj = 0;
28865 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28866 int result;
28867 void *argp1 = 0 ;
28868 int res1 = 0 ;
28869 PyObject *swig_obj[1] ;
28870
28871 if (!args) SWIG_fail;
28872 swig_obj[0] = args;
28873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28874 if (!SWIG_IsOK(res1)) {
28875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28876 }
28877 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28878 {
28879 PyThreadState* __tstate = wxPyBeginAllowThreads();
28880 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28881 wxPyEndAllowThreads(__tstate);
28882 if (PyErr_Occurred()) SWIG_fail;
28883 }
28884 resultobj = SWIG_From_int(static_cast< int >(result));
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28892 PyObject *resultobj = 0;
28893 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28894 int result;
28895 void *argp1 = 0 ;
28896 int res1 = 0 ;
28897 PyObject *swig_obj[1] ;
28898
28899 if (!args) SWIG_fail;
28900 swig_obj[0] = args;
28901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28902 if (!SWIG_IsOK(res1)) {
28903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28904 }
28905 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 resultobj = SWIG_From_int(static_cast< int >(result));
28913 return resultobj;
28914 fail:
28915 return NULL;
28916 }
28917
28918
28919 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28920 PyObject *resultobj = 0;
28921 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28922 int result;
28923 void *argp1 = 0 ;
28924 int res1 = 0 ;
28925 PyObject *swig_obj[1] ;
28926
28927 if (!args) SWIG_fail;
28928 swig_obj[0] = args;
28929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28930 if (!SWIG_IsOK(res1)) {
28931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28932 }
28933 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28934 {
28935 PyThreadState* __tstate = wxPyBeginAllowThreads();
28936 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28937 wxPyEndAllowThreads(__tstate);
28938 if (PyErr_Occurred()) SWIG_fail;
28939 }
28940 resultobj = SWIG_From_int(static_cast< int >(result));
28941 return resultobj;
28942 fail:
28943 return NULL;
28944 }
28945
28946
28947 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28948 PyObject *resultobj = 0;
28949 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28950 int result;
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_wxTimeSpan, 0 | 0 );
28958 if (!SWIG_IsOK(res1)) {
28959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28960 }
28961 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 resultobj = SWIG_From_int(static_cast< int >(result));
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28976 PyObject *resultobj = 0;
28977 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28978 wxLongLong result;
28979 void *argp1 = 0 ;
28980 int res1 = 0 ;
28981 PyObject *swig_obj[1] ;
28982
28983 if (!args) SWIG_fail;
28984 swig_obj[0] = args;
28985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28986 if (!SWIG_IsOK(res1)) {
28987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28988 }
28989 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28990 {
28991 PyThreadState* __tstate = wxPyBeginAllowThreads();
28992 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28993 wxPyEndAllowThreads(__tstate);
28994 if (PyErr_Occurred()) SWIG_fail;
28995 }
28996 {
28997 PyObject *hi, *lo, *shifter, *shifted;
28998 hi = PyLong_FromLong( (&result)->GetHi() );
28999 lo = PyLong_FromLong( (&result)->GetLo() );
29000 shifter = PyLong_FromLong(32);
29001 shifted = PyNumber_Lshift(hi, shifter);
29002 resultobj = PyNumber_Or(shifted, lo);
29003 Py_DECREF(hi);
29004 Py_DECREF(lo);
29005 Py_DECREF(shifter);
29006 Py_DECREF(shifted);
29007 }
29008 return resultobj;
29009 fail:
29010 return NULL;
29011 }
29012
29013
29014 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29015 PyObject *resultobj = 0;
29016 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29017 wxLongLong result;
29018 void *argp1 = 0 ;
29019 int res1 = 0 ;
29020 PyObject *swig_obj[1] ;
29021
29022 if (!args) SWIG_fail;
29023 swig_obj[0] = args;
29024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29025 if (!SWIG_IsOK(res1)) {
29026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29027 }
29028 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29029 {
29030 PyThreadState* __tstate = wxPyBeginAllowThreads();
29031 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 {
29036 PyObject *hi, *lo, *shifter, *shifted;
29037 hi = PyLong_FromLong( (&result)->GetHi() );
29038 lo = PyLong_FromLong( (&result)->GetLo() );
29039 shifter = PyLong_FromLong(32);
29040 shifted = PyNumber_Lshift(hi, shifter);
29041 resultobj = PyNumber_Or(shifted, lo);
29042 Py_DECREF(hi);
29043 Py_DECREF(lo);
29044 Py_DECREF(shifter);
29045 Py_DECREF(shifted);
29046 }
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29054 PyObject *resultobj = 0;
29055 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29056 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29057 wxString *arg2 = (wxString *) &arg2_defvalue ;
29058 wxString result;
29059 void *argp1 = 0 ;
29060 int res1 = 0 ;
29061 bool temp2 = false ;
29062 PyObject * obj0 = 0 ;
29063 PyObject * obj1 = 0 ;
29064 char * kwnames[] = {
29065 (char *) "self",(char *) "format", NULL
29066 };
29067
29068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29070 if (!SWIG_IsOK(res1)) {
29071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29072 }
29073 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29074 if (obj1) {
29075 {
29076 arg2 = wxString_in_helper(obj1);
29077 if (arg2 == NULL) SWIG_fail;
29078 temp2 = true;
29079 }
29080 }
29081 {
29082 PyThreadState* __tstate = wxPyBeginAllowThreads();
29083 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29084 wxPyEndAllowThreads(__tstate);
29085 if (PyErr_Occurred()) SWIG_fail;
29086 }
29087 {
29088 #if wxUSE_UNICODE
29089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29090 #else
29091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29092 #endif
29093 }
29094 {
29095 if (temp2)
29096 delete arg2;
29097 }
29098 return resultobj;
29099 fail:
29100 {
29101 if (temp2)
29102 delete arg2;
29103 }
29104 return NULL;
29105 }
29106
29107
29108 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29109 PyObject *obj;
29110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29111 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
29112 return SWIG_Py_Void();
29113 }
29114
29115 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29116 return SWIG_Python_InitShadowInstance(args);
29117 }
29118
29119 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29120 PyObject *resultobj = 0;
29121 int arg1 = (int) 0 ;
29122 int arg2 = (int) 0 ;
29123 int arg3 = (int) 0 ;
29124 int arg4 = (int) 0 ;
29125 wxDateSpan *result = 0 ;
29126 int val1 ;
29127 int ecode1 = 0 ;
29128 int val2 ;
29129 int ecode2 = 0 ;
29130 int val3 ;
29131 int ecode3 = 0 ;
29132 int val4 ;
29133 int ecode4 = 0 ;
29134 PyObject * obj0 = 0 ;
29135 PyObject * obj1 = 0 ;
29136 PyObject * obj2 = 0 ;
29137 PyObject * obj3 = 0 ;
29138 char * kwnames[] = {
29139 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
29140 };
29141
29142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29143 if (obj0) {
29144 ecode1 = SWIG_AsVal_int(obj0, &val1);
29145 if (!SWIG_IsOK(ecode1)) {
29146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
29147 }
29148 arg1 = static_cast< int >(val1);
29149 }
29150 if (obj1) {
29151 ecode2 = SWIG_AsVal_int(obj1, &val2);
29152 if (!SWIG_IsOK(ecode2)) {
29153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
29154 }
29155 arg2 = static_cast< int >(val2);
29156 }
29157 if (obj2) {
29158 ecode3 = SWIG_AsVal_int(obj2, &val3);
29159 if (!SWIG_IsOK(ecode3)) {
29160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
29161 }
29162 arg3 = static_cast< int >(val3);
29163 }
29164 if (obj3) {
29165 ecode4 = SWIG_AsVal_int(obj3, &val4);
29166 if (!SWIG_IsOK(ecode4)) {
29167 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
29168 }
29169 arg4 = static_cast< int >(val4);
29170 }
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29185 PyObject *resultobj = 0;
29186 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29187 void *argp1 = 0 ;
29188 int res1 = 0 ;
29189 PyObject *swig_obj[1] ;
29190
29191 if (!args) SWIG_fail;
29192 swig_obj[0] = args;
29193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29194 if (!SWIG_IsOK(res1)) {
29195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29196 }
29197 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29198 {
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 delete arg1;
29201
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 resultobj = SWIG_Py_Void();
29206 return resultobj;
29207 fail:
29208 return NULL;
29209 }
29210
29211
29212 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29213 PyObject *resultobj = 0;
29214 int arg1 ;
29215 wxDateSpan result;
29216 int val1 ;
29217 int ecode1 = 0 ;
29218 PyObject * obj0 = 0 ;
29219 char * kwnames[] = {
29220 (char *) "days", NULL
29221 };
29222
29223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29224 ecode1 = SWIG_AsVal_int(obj0, &val1);
29225 if (!SWIG_IsOK(ecode1)) {
29226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29227 }
29228 arg1 = static_cast< int >(val1);
29229 {
29230 PyThreadState* __tstate = wxPyBeginAllowThreads();
29231 result = wxDateSpan::Days(arg1);
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 wxDateSpan result;
29245
29246 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29247 {
29248 PyThreadState* __tstate = wxPyBeginAllowThreads();
29249 result = wxDateSpan::Day();
29250 wxPyEndAllowThreads(__tstate);
29251 if (PyErr_Occurred()) SWIG_fail;
29252 }
29253 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29261 PyObject *resultobj = 0;
29262 int arg1 ;
29263 wxDateSpan result;
29264 int val1 ;
29265 int ecode1 = 0 ;
29266 PyObject * obj0 = 0 ;
29267 char * kwnames[] = {
29268 (char *) "weeks", NULL
29269 };
29270
29271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29272 ecode1 = SWIG_AsVal_int(obj0, &val1);
29273 if (!SWIG_IsOK(ecode1)) {
29274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29275 }
29276 arg1 = static_cast< int >(val1);
29277 {
29278 PyThreadState* __tstate = wxPyBeginAllowThreads();
29279 result = wxDateSpan::Weeks(arg1);
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29291 PyObject *resultobj = 0;
29292 wxDateSpan result;
29293
29294 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 result = wxDateSpan::Week();
29298 wxPyEndAllowThreads(__tstate);
29299 if (PyErr_Occurred()) SWIG_fail;
29300 }
29301 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29302 return resultobj;
29303 fail:
29304 return NULL;
29305 }
29306
29307
29308 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29309 PyObject *resultobj = 0;
29310 int arg1 ;
29311 wxDateSpan result;
29312 int val1 ;
29313 int ecode1 = 0 ;
29314 PyObject * obj0 = 0 ;
29315 char * kwnames[] = {
29316 (char *) "mon", NULL
29317 };
29318
29319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29320 ecode1 = SWIG_AsVal_int(obj0, &val1);
29321 if (!SWIG_IsOK(ecode1)) {
29322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29323 }
29324 arg1 = static_cast< int >(val1);
29325 {
29326 PyThreadState* __tstate = wxPyBeginAllowThreads();
29327 result = wxDateSpan::Months(arg1);
29328 wxPyEndAllowThreads(__tstate);
29329 if (PyErr_Occurred()) SWIG_fail;
29330 }
29331 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29332 return resultobj;
29333 fail:
29334 return NULL;
29335 }
29336
29337
29338 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29339 PyObject *resultobj = 0;
29340 wxDateSpan result;
29341
29342 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 result = wxDateSpan::Month();
29346 wxPyEndAllowThreads(__tstate);
29347 if (PyErr_Occurred()) SWIG_fail;
29348 }
29349 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29357 PyObject *resultobj = 0;
29358 int arg1 ;
29359 wxDateSpan result;
29360 int val1 ;
29361 int ecode1 = 0 ;
29362 PyObject * obj0 = 0 ;
29363 char * kwnames[] = {
29364 (char *) "years", NULL
29365 };
29366
29367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29368 ecode1 = SWIG_AsVal_int(obj0, &val1);
29369 if (!SWIG_IsOK(ecode1)) {
29370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29371 }
29372 arg1 = static_cast< int >(val1);
29373 {
29374 PyThreadState* __tstate = wxPyBeginAllowThreads();
29375 result = wxDateSpan::Years(arg1);
29376 wxPyEndAllowThreads(__tstate);
29377 if (PyErr_Occurred()) SWIG_fail;
29378 }
29379 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29387 PyObject *resultobj = 0;
29388 wxDateSpan result;
29389
29390 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29391 {
29392 PyThreadState* __tstate = wxPyBeginAllowThreads();
29393 result = wxDateSpan::Year();
29394 wxPyEndAllowThreads(__tstate);
29395 if (PyErr_Occurred()) SWIG_fail;
29396 }
29397 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj = 0;
29406 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29407 int arg2 ;
29408 wxDateSpan *result = 0 ;
29409 void *argp1 = 0 ;
29410 int res1 = 0 ;
29411 int val2 ;
29412 int ecode2 = 0 ;
29413 PyObject * obj0 = 0 ;
29414 PyObject * obj1 = 0 ;
29415 char * kwnames[] = {
29416 (char *) "self",(char *) "n", NULL
29417 };
29418
29419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29421 if (!SWIG_IsOK(res1)) {
29422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29423 }
29424 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29425 ecode2 = SWIG_AsVal_int(obj1, &val2);
29426 if (!SWIG_IsOK(ecode2)) {
29427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29428 }
29429 arg2 = static_cast< int >(val2);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 {
29433 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29434 result = (wxDateSpan *) &_result_ref;
29435 }
29436 wxPyEndAllowThreads(__tstate);
29437 if (PyErr_Occurred()) SWIG_fail;
29438 }
29439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = 0;
29448 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29449 int arg2 ;
29450 wxDateSpan *result = 0 ;
29451 void *argp1 = 0 ;
29452 int res1 = 0 ;
29453 int val2 ;
29454 int ecode2 = 0 ;
29455 PyObject * obj0 = 0 ;
29456 PyObject * obj1 = 0 ;
29457 char * kwnames[] = {
29458 (char *) "self",(char *) "n", NULL
29459 };
29460
29461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29463 if (!SWIG_IsOK(res1)) {
29464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29465 }
29466 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29467 ecode2 = SWIG_AsVal_int(obj1, &val2);
29468 if (!SWIG_IsOK(ecode2)) {
29469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29470 }
29471 arg2 = static_cast< int >(val2);
29472 {
29473 PyThreadState* __tstate = wxPyBeginAllowThreads();
29474 {
29475 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29476 result = (wxDateSpan *) &_result_ref;
29477 }
29478 wxPyEndAllowThreads(__tstate);
29479 if (PyErr_Occurred()) SWIG_fail;
29480 }
29481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29482 return resultobj;
29483 fail:
29484 return NULL;
29485 }
29486
29487
29488 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29489 PyObject *resultobj = 0;
29490 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29491 int arg2 ;
29492 wxDateSpan *result = 0 ;
29493 void *argp1 = 0 ;
29494 int res1 = 0 ;
29495 int val2 ;
29496 int ecode2 = 0 ;
29497 PyObject * obj0 = 0 ;
29498 PyObject * obj1 = 0 ;
29499 char * kwnames[] = {
29500 (char *) "self",(char *) "n", NULL
29501 };
29502
29503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29505 if (!SWIG_IsOK(res1)) {
29506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29507 }
29508 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29509 ecode2 = SWIG_AsVal_int(obj1, &val2);
29510 if (!SWIG_IsOK(ecode2)) {
29511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29512 }
29513 arg2 = static_cast< int >(val2);
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 {
29517 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29518 result = (wxDateSpan *) &_result_ref;
29519 }
29520 wxPyEndAllowThreads(__tstate);
29521 if (PyErr_Occurred()) SWIG_fail;
29522 }
29523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29524 return resultobj;
29525 fail:
29526 return NULL;
29527 }
29528
29529
29530 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29531 PyObject *resultobj = 0;
29532 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29533 int arg2 ;
29534 wxDateSpan *result = 0 ;
29535 void *argp1 = 0 ;
29536 int res1 = 0 ;
29537 int val2 ;
29538 int ecode2 = 0 ;
29539 PyObject * obj0 = 0 ;
29540 PyObject * obj1 = 0 ;
29541 char * kwnames[] = {
29542 (char *) "self",(char *) "n", NULL
29543 };
29544
29545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29547 if (!SWIG_IsOK(res1)) {
29548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29549 }
29550 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29551 ecode2 = SWIG_AsVal_int(obj1, &val2);
29552 if (!SWIG_IsOK(ecode2)) {
29553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29554 }
29555 arg2 = static_cast< int >(val2);
29556 {
29557 PyThreadState* __tstate = wxPyBeginAllowThreads();
29558 {
29559 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29560 result = (wxDateSpan *) &_result_ref;
29561 }
29562 wxPyEndAllowThreads(__tstate);
29563 if (PyErr_Occurred()) SWIG_fail;
29564 }
29565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29566 return resultobj;
29567 fail:
29568 return NULL;
29569 }
29570
29571
29572 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29573 PyObject *resultobj = 0;
29574 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29575 int result;
29576 void *argp1 = 0 ;
29577 int res1 = 0 ;
29578 PyObject *swig_obj[1] ;
29579
29580 if (!args) SWIG_fail;
29581 swig_obj[0] = args;
29582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29583 if (!SWIG_IsOK(res1)) {
29584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29585 }
29586 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29587 {
29588 PyThreadState* __tstate = wxPyBeginAllowThreads();
29589 result = (int)((wxDateSpan const *)arg1)->GetYears();
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 resultobj = SWIG_From_int(static_cast< int >(result));
29594 return resultobj;
29595 fail:
29596 return NULL;
29597 }
29598
29599
29600 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29601 PyObject *resultobj = 0;
29602 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29603 int result;
29604 void *argp1 = 0 ;
29605 int res1 = 0 ;
29606 PyObject *swig_obj[1] ;
29607
29608 if (!args) SWIG_fail;
29609 swig_obj[0] = args;
29610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29611 if (!SWIG_IsOK(res1)) {
29612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29613 }
29614 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29618 wxPyEndAllowThreads(__tstate);
29619 if (PyErr_Occurred()) SWIG_fail;
29620 }
29621 resultobj = SWIG_From_int(static_cast< int >(result));
29622 return resultobj;
29623 fail:
29624 return NULL;
29625 }
29626
29627
29628 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29629 PyObject *resultobj = 0;
29630 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29631 int result;
29632 void *argp1 = 0 ;
29633 int res1 = 0 ;
29634 PyObject *swig_obj[1] ;
29635
29636 if (!args) SWIG_fail;
29637 swig_obj[0] = args;
29638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29639 if (!SWIG_IsOK(res1)) {
29640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29641 }
29642 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29643 {
29644 PyThreadState* __tstate = wxPyBeginAllowThreads();
29645 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 resultobj = SWIG_From_int(static_cast< int >(result));
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29657 PyObject *resultobj = 0;
29658 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29659 int result;
29660 void *argp1 = 0 ;
29661 int res1 = 0 ;
29662 PyObject *swig_obj[1] ;
29663
29664 if (!args) SWIG_fail;
29665 swig_obj[0] = args;
29666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29667 if (!SWIG_IsOK(res1)) {
29668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29669 }
29670 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29671 {
29672 PyThreadState* __tstate = wxPyBeginAllowThreads();
29673 result = (int)((wxDateSpan const *)arg1)->GetDays();
29674 wxPyEndAllowThreads(__tstate);
29675 if (PyErr_Occurred()) SWIG_fail;
29676 }
29677 resultobj = SWIG_From_int(static_cast< int >(result));
29678 return resultobj;
29679 fail:
29680 return NULL;
29681 }
29682
29683
29684 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29685 PyObject *resultobj = 0;
29686 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29687 int result;
29688 void *argp1 = 0 ;
29689 int res1 = 0 ;
29690 PyObject *swig_obj[1] ;
29691
29692 if (!args) SWIG_fail;
29693 swig_obj[0] = args;
29694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29695 if (!SWIG_IsOK(res1)) {
29696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29697 }
29698 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29699 {
29700 PyThreadState* __tstate = wxPyBeginAllowThreads();
29701 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29702 wxPyEndAllowThreads(__tstate);
29703 if (PyErr_Occurred()) SWIG_fail;
29704 }
29705 resultobj = SWIG_From_int(static_cast< int >(result));
29706 return resultobj;
29707 fail:
29708 return NULL;
29709 }
29710
29711
29712 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29713 PyObject *resultobj = 0;
29714 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29715 wxDateSpan *arg2 = 0 ;
29716 wxDateSpan *result = 0 ;
29717 void *argp1 = 0 ;
29718 int res1 = 0 ;
29719 void *argp2 = 0 ;
29720 int res2 = 0 ;
29721 PyObject * obj0 = 0 ;
29722 PyObject * obj1 = 0 ;
29723 char * kwnames[] = {
29724 (char *) "self",(char *) "other", NULL
29725 };
29726
29727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29729 if (!SWIG_IsOK(res1)) {
29730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29731 }
29732 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29733 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29734 if (!SWIG_IsOK(res2)) {
29735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29736 }
29737 if (!argp2) {
29738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29739 }
29740 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 {
29744 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29745 result = (wxDateSpan *) &_result_ref;
29746 }
29747 wxPyEndAllowThreads(__tstate);
29748 if (PyErr_Occurred()) SWIG_fail;
29749 }
29750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29751 return resultobj;
29752 fail:
29753 return NULL;
29754 }
29755
29756
29757 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj = 0;
29759 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29760 wxDateSpan *arg2 = 0 ;
29761 wxDateSpan *result = 0 ;
29762 void *argp1 = 0 ;
29763 int res1 = 0 ;
29764 void *argp2 = 0 ;
29765 int res2 = 0 ;
29766 PyObject * obj0 = 0 ;
29767 PyObject * obj1 = 0 ;
29768 char * kwnames[] = {
29769 (char *) "self",(char *) "other", NULL
29770 };
29771
29772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29774 if (!SWIG_IsOK(res1)) {
29775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29776 }
29777 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29778 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29779 if (!SWIG_IsOK(res2)) {
29780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29781 }
29782 if (!argp2) {
29783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29784 }
29785 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 {
29789 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*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, 0 | 0 );
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29803 PyObject *resultobj = 0;
29804 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29805 wxDateSpan *result = 0 ;
29806 void *argp1 = 0 ;
29807 int res1 = 0 ;
29808 PyObject *swig_obj[1] ;
29809
29810 if (!args) SWIG_fail;
29811 swig_obj[0] = args;
29812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29813 if (!SWIG_IsOK(res1)) {
29814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29815 }
29816 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29817 {
29818 PyThreadState* __tstate = wxPyBeginAllowThreads();
29819 {
29820 wxDateSpan &_result_ref = (arg1)->Neg();
29821 result = (wxDateSpan *) &_result_ref;
29822 }
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29827 return resultobj;
29828 fail:
29829 return NULL;
29830 }
29831
29832
29833 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29834 PyObject *resultobj = 0;
29835 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29836 int arg2 ;
29837 wxDateSpan *result = 0 ;
29838 void *argp1 = 0 ;
29839 int res1 = 0 ;
29840 int val2 ;
29841 int ecode2 = 0 ;
29842 PyObject * obj0 = 0 ;
29843 PyObject * obj1 = 0 ;
29844 char * kwnames[] = {
29845 (char *) "self",(char *) "factor", NULL
29846 };
29847
29848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29850 if (!SWIG_IsOK(res1)) {
29851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29852 }
29853 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29854 ecode2 = SWIG_AsVal_int(obj1, &val2);
29855 if (!SWIG_IsOK(ecode2)) {
29856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29857 }
29858 arg2 = static_cast< int >(val2);
29859 {
29860 PyThreadState* __tstate = wxPyBeginAllowThreads();
29861 {
29862 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29863 result = (wxDateSpan *) &_result_ref;
29864 }
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj = 0;
29877 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29878 wxDateSpan *arg2 = 0 ;
29879 wxDateSpan *result = 0 ;
29880 void *argp1 = 0 ;
29881 int res1 = 0 ;
29882 void *argp2 = 0 ;
29883 int res2 = 0 ;
29884 PyObject * obj0 = 0 ;
29885 PyObject * obj1 = 0 ;
29886 char * kwnames[] = {
29887 (char *) "self",(char *) "other", NULL
29888 };
29889
29890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29892 if (!SWIG_IsOK(res1)) {
29893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29894 }
29895 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29897 if (!SWIG_IsOK(res2)) {
29898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29899 }
29900 if (!argp2) {
29901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29902 }
29903 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 {
29907 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29908 result = (wxDateSpan *) &_result_ref;
29909 }
29910 wxPyEndAllowThreads(__tstate);
29911 if (PyErr_Occurred()) SWIG_fail;
29912 }
29913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29921 PyObject *resultobj = 0;
29922 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29923 wxDateSpan *arg2 = 0 ;
29924 wxDateSpan *result = 0 ;
29925 void *argp1 = 0 ;
29926 int res1 = 0 ;
29927 void *argp2 = 0 ;
29928 int res2 = 0 ;
29929 PyObject * obj0 = 0 ;
29930 PyObject * obj1 = 0 ;
29931 char * kwnames[] = {
29932 (char *) "self",(char *) "other", NULL
29933 };
29934
29935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29937 if (!SWIG_IsOK(res1)) {
29938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29939 }
29940 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29942 if (!SWIG_IsOK(res2)) {
29943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29944 }
29945 if (!argp2) {
29946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29947 }
29948 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29949 {
29950 PyThreadState* __tstate = wxPyBeginAllowThreads();
29951 {
29952 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29953 result = (wxDateSpan *) &_result_ref;
29954 }
29955 wxPyEndAllowThreads(__tstate);
29956 if (PyErr_Occurred()) SWIG_fail;
29957 }
29958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29966 PyObject *resultobj = 0;
29967 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29968 wxDateSpan *result = 0 ;
29969 void *argp1 = 0 ;
29970 int res1 = 0 ;
29971 PyObject *swig_obj[1] ;
29972
29973 if (!args) SWIG_fail;
29974 swig_obj[0] = args;
29975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29976 if (!SWIG_IsOK(res1)) {
29977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29978 }
29979 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29980 {
29981 PyThreadState* __tstate = wxPyBeginAllowThreads();
29982 {
29983 wxDateSpan &_result_ref = (arg1)->operator -();
29984 result = (wxDateSpan *) &_result_ref;
29985 }
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29997 PyObject *resultobj = 0;
29998 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29999 int arg2 ;
30000 wxDateSpan *result = 0 ;
30001 void *argp1 = 0 ;
30002 int res1 = 0 ;
30003 int val2 ;
30004 int ecode2 = 0 ;
30005 PyObject * obj0 = 0 ;
30006 PyObject * obj1 = 0 ;
30007 char * kwnames[] = {
30008 (char *) "self",(char *) "factor", NULL
30009 };
30010
30011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30013 if (!SWIG_IsOK(res1)) {
30014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30015 }
30016 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30017 ecode2 = SWIG_AsVal_int(obj1, &val2);
30018 if (!SWIG_IsOK(ecode2)) {
30019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30020 }
30021 arg2 = static_cast< int >(val2);
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 {
30025 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30026 result = (wxDateSpan *) &_result_ref;
30027 }
30028 wxPyEndAllowThreads(__tstate);
30029 if (PyErr_Occurred()) SWIG_fail;
30030 }
30031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30032 return resultobj;
30033 fail:
30034 return NULL;
30035 }
30036
30037
30038 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30039 PyObject *resultobj = 0;
30040 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30041 wxDateSpan *arg2 = 0 ;
30042 wxDateSpan result;
30043 void *argp1 = 0 ;
30044 int res1 = 0 ;
30045 void *argp2 = 0 ;
30046 int res2 = 0 ;
30047 PyObject * obj0 = 0 ;
30048 PyObject * obj1 = 0 ;
30049 char * kwnames[] = {
30050 (char *) "self",(char *) "other", NULL
30051 };
30052
30053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30055 if (!SWIG_IsOK(res1)) {
30056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30057 }
30058 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30059 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30060 if (!SWIG_IsOK(res2)) {
30061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30062 }
30063 if (!argp2) {
30064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30065 }
30066 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30067 {
30068 PyThreadState* __tstate = wxPyBeginAllowThreads();
30069 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30070 wxPyEndAllowThreads(__tstate);
30071 if (PyErr_Occurred()) SWIG_fail;
30072 }
30073 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30074 return resultobj;
30075 fail:
30076 return NULL;
30077 }
30078
30079
30080 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30081 PyObject *resultobj = 0;
30082 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30083 wxDateSpan *arg2 = 0 ;
30084 wxDateSpan result;
30085 void *argp1 = 0 ;
30086 int res1 = 0 ;
30087 void *argp2 = 0 ;
30088 int res2 = 0 ;
30089 PyObject * obj0 = 0 ;
30090 PyObject * obj1 = 0 ;
30091 char * kwnames[] = {
30092 (char *) "self",(char *) "other", NULL
30093 };
30094
30095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30097 if (!SWIG_IsOK(res1)) {
30098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30099 }
30100 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30102 if (!SWIG_IsOK(res2)) {
30103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30104 }
30105 if (!argp2) {
30106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30107 }
30108 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30109 {
30110 PyThreadState* __tstate = wxPyBeginAllowThreads();
30111 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
30112 wxPyEndAllowThreads(__tstate);
30113 if (PyErr_Occurred()) SWIG_fail;
30114 }
30115 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30116 return resultobj;
30117 fail:
30118 return NULL;
30119 }
30120
30121
30122 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30123 PyObject *resultobj = 0;
30124 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30125 int arg2 ;
30126 wxDateSpan result;
30127 void *argp1 = 0 ;
30128 int res1 = 0 ;
30129 int val2 ;
30130 int ecode2 = 0 ;
30131 PyObject * obj0 = 0 ;
30132 PyObject * obj1 = 0 ;
30133 char * kwnames[] = {
30134 (char *) "self",(char *) "n", NULL
30135 };
30136
30137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
30138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30139 if (!SWIG_IsOK(res1)) {
30140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30141 }
30142 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30143 ecode2 = SWIG_AsVal_int(obj1, &val2);
30144 if (!SWIG_IsOK(ecode2)) {
30145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
30146 }
30147 arg2 = static_cast< int >(val2);
30148 {
30149 PyThreadState* __tstate = wxPyBeginAllowThreads();
30150 result = wxDateSpan___mul__(arg1,arg2);
30151 wxPyEndAllowThreads(__tstate);
30152 if (PyErr_Occurred()) SWIG_fail;
30153 }
30154 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30155 return resultobj;
30156 fail:
30157 return NULL;
30158 }
30159
30160
30161 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30162 PyObject *resultobj = 0;
30163 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30164 int arg2 ;
30165 wxDateSpan result;
30166 void *argp1 = 0 ;
30167 int res1 = 0 ;
30168 int val2 ;
30169 int ecode2 = 0 ;
30170 PyObject * obj0 = 0 ;
30171 PyObject * obj1 = 0 ;
30172 char * kwnames[] = {
30173 (char *) "self",(char *) "n", NULL
30174 };
30175
30176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30178 if (!SWIG_IsOK(res1)) {
30179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30180 }
30181 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30182 ecode2 = SWIG_AsVal_int(obj1, &val2);
30183 if (!SWIG_IsOK(ecode2)) {
30184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30185 }
30186 arg2 = static_cast< int >(val2);
30187 {
30188 PyThreadState* __tstate = wxPyBeginAllowThreads();
30189 result = wxDateSpan___rmul__(arg1,arg2);
30190 wxPyEndAllowThreads(__tstate);
30191 if (PyErr_Occurred()) SWIG_fail;
30192 }
30193 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30194 return resultobj;
30195 fail:
30196 return NULL;
30197 }
30198
30199
30200 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30201 PyObject *resultobj = 0;
30202 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30203 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30204 bool result;
30205 void *argp1 = 0 ;
30206 int res1 = 0 ;
30207 void *argp2 = 0 ;
30208 int res2 = 0 ;
30209 PyObject * obj0 = 0 ;
30210 PyObject * obj1 = 0 ;
30211 char * kwnames[] = {
30212 (char *) "self",(char *) "other", NULL
30213 };
30214
30215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30217 if (!SWIG_IsOK(res1)) {
30218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30219 }
30220 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30222 if (!SWIG_IsOK(res2)) {
30223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30224 }
30225 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30226 {
30227 PyThreadState* __tstate = wxPyBeginAllowThreads();
30228 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30229 wxPyEndAllowThreads(__tstate);
30230 if (PyErr_Occurred()) SWIG_fail;
30231 }
30232 {
30233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30234 }
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30242 PyObject *resultobj = 0;
30243 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30244 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30245 bool result;
30246 void *argp1 = 0 ;
30247 int res1 = 0 ;
30248 void *argp2 = 0 ;
30249 int res2 = 0 ;
30250 PyObject * obj0 = 0 ;
30251 PyObject * obj1 = 0 ;
30252 char * kwnames[] = {
30253 (char *) "self",(char *) "other", NULL
30254 };
30255
30256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30258 if (!SWIG_IsOK(res1)) {
30259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30260 }
30261 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30263 if (!SWIG_IsOK(res2)) {
30264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30265 }
30266 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30267 {
30268 PyThreadState* __tstate = wxPyBeginAllowThreads();
30269 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30270 wxPyEndAllowThreads(__tstate);
30271 if (PyErr_Occurred()) SWIG_fail;
30272 }
30273 {
30274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30275 }
30276 return resultobj;
30277 fail:
30278 return NULL;
30279 }
30280
30281
30282 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30283 PyObject *obj;
30284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30285 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30286 return SWIG_Py_Void();
30287 }
30288
30289 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30290 return SWIG_Python_InitShadowInstance(args);
30291 }
30292
30293 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30294 PyObject *resultobj = 0;
30295 long result;
30296
30297 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30298 {
30299 PyThreadState* __tstate = wxPyBeginAllowThreads();
30300 result = (long)wxGetLocalTime();
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 resultobj = SWIG_From_long(static_cast< long >(result));
30305 return resultobj;
30306 fail:
30307 return NULL;
30308 }
30309
30310
30311 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30312 PyObject *resultobj = 0;
30313 long result;
30314
30315 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30316 {
30317 PyThreadState* __tstate = wxPyBeginAllowThreads();
30318 result = (long)wxGetUTCTime();
30319 wxPyEndAllowThreads(__tstate);
30320 if (PyErr_Occurred()) SWIG_fail;
30321 }
30322 resultobj = SWIG_From_long(static_cast< long >(result));
30323 return resultobj;
30324 fail:
30325 return NULL;
30326 }
30327
30328
30329 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30330 PyObject *resultobj = 0;
30331 long result;
30332
30333 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 result = (long)wxGetCurrentTime();
30337 wxPyEndAllowThreads(__tstate);
30338 if (PyErr_Occurred()) SWIG_fail;
30339 }
30340 resultobj = SWIG_From_long(static_cast< long >(result));
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30348 PyObject *resultobj = 0;
30349 wxLongLong result;
30350
30351 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 result = wxGetLocalTimeMillis();
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 {
30359 PyObject *hi, *lo, *shifter, *shifted;
30360 hi = PyLong_FromLong( (&result)->GetHi() );
30361 lo = PyLong_FromLong( (&result)->GetLo() );
30362 shifter = PyLong_FromLong(32);
30363 shifted = PyNumber_Lshift(hi, shifter);
30364 resultobj = PyNumber_Or(shifted, lo);
30365 Py_DECREF(hi);
30366 Py_DECREF(lo);
30367 Py_DECREF(shifter);
30368 Py_DECREF(shifted);
30369 }
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30377 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30378 return 1;
30379 }
30380
30381
30382 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30383 PyObject *pyobj = 0;
30384
30385 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30386 return pyobj;
30387 }
30388
30389
30390 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30391 PyObject *resultobj = 0;
30392 wxDataFormatId arg1 ;
30393 wxDataFormat *result = 0 ;
30394 int val1 ;
30395 int ecode1 = 0 ;
30396 PyObject * obj0 = 0 ;
30397 char * kwnames[] = {
30398 (char *) "type", NULL
30399 };
30400
30401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30402 ecode1 = SWIG_AsVal_int(obj0, &val1);
30403 if (!SWIG_IsOK(ecode1)) {
30404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30405 }
30406 arg1 = static_cast< wxDataFormatId >(val1);
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 result = (wxDataFormat *)new wxDataFormat(arg1);
30410 wxPyEndAllowThreads(__tstate);
30411 if (PyErr_Occurred()) SWIG_fail;
30412 }
30413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30414 return resultobj;
30415 fail:
30416 return NULL;
30417 }
30418
30419
30420 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30421 PyObject *resultobj = 0;
30422 wxString *arg1 = 0 ;
30423 wxDataFormat *result = 0 ;
30424 bool temp1 = false ;
30425 PyObject * obj0 = 0 ;
30426 char * kwnames[] = {
30427 (char *) "format", NULL
30428 };
30429
30430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30431 {
30432 arg1 = wxString_in_helper(obj0);
30433 if (arg1 == NULL) SWIG_fail;
30434 temp1 = true;
30435 }
30436 {
30437 PyThreadState* __tstate = wxPyBeginAllowThreads();
30438 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30439 wxPyEndAllowThreads(__tstate);
30440 if (PyErr_Occurred()) SWIG_fail;
30441 }
30442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30443 {
30444 if (temp1)
30445 delete arg1;
30446 }
30447 return resultobj;
30448 fail:
30449 {
30450 if (temp1)
30451 delete arg1;
30452 }
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30458 PyObject *resultobj = 0;
30459 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30460 void *argp1 = 0 ;
30461 int res1 = 0 ;
30462 PyObject *swig_obj[1] ;
30463
30464 if (!args) SWIG_fail;
30465 swig_obj[0] = args;
30466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30467 if (!SWIG_IsOK(res1)) {
30468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30469 }
30470 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 delete arg1;
30474
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 resultobj = SWIG_Py_Void();
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30486 PyObject *resultobj = 0;
30487 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30488 wxDataFormatId arg2 ;
30489 bool result;
30490 void *argp1 = 0 ;
30491 int res1 = 0 ;
30492 int val2 ;
30493 int ecode2 = 0 ;
30494
30495 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30497 if (!SWIG_IsOK(res1)) {
30498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30499 }
30500 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30501 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30502 if (!SWIG_IsOK(ecode2)) {
30503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30504 }
30505 arg2 = static_cast< wxDataFormatId >(val2);
30506 {
30507 PyThreadState* __tstate = wxPyBeginAllowThreads();
30508 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 {
30513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30514 }
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30522 PyObject *resultobj = 0;
30523 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30524 wxDataFormatId arg2 ;
30525 bool result;
30526 void *argp1 = 0 ;
30527 int res1 = 0 ;
30528 int val2 ;
30529 int ecode2 = 0 ;
30530
30531 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30533 if (!SWIG_IsOK(res1)) {
30534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30535 }
30536 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30537 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30538 if (!SWIG_IsOK(ecode2)) {
30539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30540 }
30541 arg2 = static_cast< wxDataFormatId >(val2);
30542 {
30543 PyThreadState* __tstate = wxPyBeginAllowThreads();
30544 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30545 wxPyEndAllowThreads(__tstate);
30546 if (PyErr_Occurred()) SWIG_fail;
30547 }
30548 {
30549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30550 }
30551 return resultobj;
30552 fail:
30553 return NULL;
30554 }
30555
30556
30557 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30558 PyObject *resultobj = 0;
30559 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30560 wxDataFormat *arg2 = 0 ;
30561 bool result;
30562 void *argp1 = 0 ;
30563 int res1 = 0 ;
30564 void *argp2 = 0 ;
30565 int res2 = 0 ;
30566
30567 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30569 if (!SWIG_IsOK(res1)) {
30570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30571 }
30572 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30573 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30574 if (!SWIG_IsOK(res2)) {
30575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30576 }
30577 if (!argp2) {
30578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30579 }
30580 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30584 wxPyEndAllowThreads(__tstate);
30585 if (PyErr_Occurred()) SWIG_fail;
30586 }
30587 {
30588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30589 }
30590 return resultobj;
30591 fail:
30592 return NULL;
30593 }
30594
30595
30596 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30597 int argc;
30598 PyObject *argv[3];
30599
30600 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30601 --argc;
30602 if (argc == 2) {
30603 int _v = 0;
30604 {
30605 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30606 _v = SWIG_CheckState(res);
30607 }
30608 if (!_v) goto check_1;
30609 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30610 }
30611 check_1:
30612
30613 if (argc == 2) {
30614 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30615 }
30616
30617 fail:
30618 Py_INCREF(Py_NotImplemented);
30619 return Py_NotImplemented;
30620 }
30621
30622
30623 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30624 PyObject *resultobj = 0;
30625 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30626 wxDataFormat *arg2 = 0 ;
30627 bool result;
30628 void *argp1 = 0 ;
30629 int res1 = 0 ;
30630 void *argp2 = 0 ;
30631 int res2 = 0 ;
30632
30633 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30635 if (!SWIG_IsOK(res1)) {
30636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30637 }
30638 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30639 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30640 if (!SWIG_IsOK(res2)) {
30641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30642 }
30643 if (!argp2) {
30644 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30645 }
30646 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30647 {
30648 PyThreadState* __tstate = wxPyBeginAllowThreads();
30649 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30650 wxPyEndAllowThreads(__tstate);
30651 if (PyErr_Occurred()) SWIG_fail;
30652 }
30653 {
30654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30655 }
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30663 int argc;
30664 PyObject *argv[3];
30665
30666 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30667 --argc;
30668 if (argc == 2) {
30669 int _v = 0;
30670 {
30671 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30672 _v = SWIG_CheckState(res);
30673 }
30674 if (!_v) goto check_1;
30675 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30676 }
30677 check_1:
30678
30679 if (argc == 2) {
30680 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30681 }
30682
30683 fail:
30684 Py_INCREF(Py_NotImplemented);
30685 return Py_NotImplemented;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30690 PyObject *resultobj = 0;
30691 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30692 wxDataFormatId arg2 ;
30693 void *argp1 = 0 ;
30694 int res1 = 0 ;
30695 int val2 ;
30696 int ecode2 = 0 ;
30697 PyObject * obj0 = 0 ;
30698 PyObject * obj1 = 0 ;
30699 char * kwnames[] = {
30700 (char *) "self",(char *) "format", NULL
30701 };
30702
30703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30705 if (!SWIG_IsOK(res1)) {
30706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30707 }
30708 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30709 ecode2 = SWIG_AsVal_int(obj1, &val2);
30710 if (!SWIG_IsOK(ecode2)) {
30711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30712 }
30713 arg2 = static_cast< wxDataFormatId >(val2);
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 (arg1)->SetType(arg2);
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 resultobj = SWIG_Py_Void();
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30728 PyObject *resultobj = 0;
30729 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30730 wxDataFormatId result;
30731 void *argp1 = 0 ;
30732 int res1 = 0 ;
30733 PyObject *swig_obj[1] ;
30734
30735 if (!args) SWIG_fail;
30736 swig_obj[0] = args;
30737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30738 if (!SWIG_IsOK(res1)) {
30739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30740 }
30741 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30745 wxPyEndAllowThreads(__tstate);
30746 if (PyErr_Occurred()) SWIG_fail;
30747 }
30748 resultobj = SWIG_From_int(static_cast< int >(result));
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30756 PyObject *resultobj = 0;
30757 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30758 wxString result;
30759 void *argp1 = 0 ;
30760 int res1 = 0 ;
30761 PyObject *swig_obj[1] ;
30762
30763 if (!args) SWIG_fail;
30764 swig_obj[0] = args;
30765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30766 if (!SWIG_IsOK(res1)) {
30767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30768 }
30769 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30770 {
30771 PyThreadState* __tstate = wxPyBeginAllowThreads();
30772 result = ((wxDataFormat const *)arg1)->GetId();
30773 wxPyEndAllowThreads(__tstate);
30774 if (PyErr_Occurred()) SWIG_fail;
30775 }
30776 {
30777 #if wxUSE_UNICODE
30778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30779 #else
30780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30781 #endif
30782 }
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj = 0;
30791 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30792 wxString *arg2 = 0 ;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 bool temp2 = false ;
30796 PyObject * obj0 = 0 ;
30797 PyObject * obj1 = 0 ;
30798 char * kwnames[] = {
30799 (char *) "self",(char *) "format", NULL
30800 };
30801
30802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30804 if (!SWIG_IsOK(res1)) {
30805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30806 }
30807 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30808 {
30809 arg2 = wxString_in_helper(obj1);
30810 if (arg2 == NULL) SWIG_fail;
30811 temp2 = true;
30812 }
30813 {
30814 PyThreadState* __tstate = wxPyBeginAllowThreads();
30815 (arg1)->SetId((wxString const &)*arg2);
30816 wxPyEndAllowThreads(__tstate);
30817 if (PyErr_Occurred()) SWIG_fail;
30818 }
30819 resultobj = SWIG_Py_Void();
30820 {
30821 if (temp2)
30822 delete arg2;
30823 }
30824 return resultobj;
30825 fail:
30826 {
30827 if (temp2)
30828 delete arg2;
30829 }
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30835 PyObject *obj;
30836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30837 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30838 return SWIG_Py_Void();
30839 }
30840
30841 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30842 return SWIG_Python_InitShadowInstance(args);
30843 }
30844
30845 SWIGINTERN int FormatInvalid_set(PyObject *) {
30846 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30847 return 1;
30848 }
30849
30850
30851 SWIGINTERN PyObject *FormatInvalid_get(void) {
30852 PyObject *pyobj = 0;
30853
30854 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30855 return pyobj;
30856 }
30857
30858
30859 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30860 PyObject *resultobj = 0;
30861 wxDataObject *arg1 = (wxDataObject *) 0 ;
30862 void *argp1 = 0 ;
30863 int res1 = 0 ;
30864 PyObject *swig_obj[1] ;
30865
30866 if (!args) SWIG_fail;
30867 swig_obj[0] = args;
30868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30869 if (!SWIG_IsOK(res1)) {
30870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30871 }
30872 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30873 {
30874 PyThreadState* __tstate = wxPyBeginAllowThreads();
30875 delete arg1;
30876
30877 wxPyEndAllowThreads(__tstate);
30878 if (PyErr_Occurred()) SWIG_fail;
30879 }
30880 resultobj = SWIG_Py_Void();
30881 return resultobj;
30882 fail:
30883 return NULL;
30884 }
30885
30886
30887 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30888 PyObject *resultobj = 0;
30889 wxDataObject *arg1 = (wxDataObject *) 0 ;
30890 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30891 SwigValueWrapper<wxDataFormat > result;
30892 void *argp1 = 0 ;
30893 int res1 = 0 ;
30894 int val2 ;
30895 int ecode2 = 0 ;
30896 PyObject * obj0 = 0 ;
30897 PyObject * obj1 = 0 ;
30898 char * kwnames[] = {
30899 (char *) "self",(char *) "dir", NULL
30900 };
30901
30902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30904 if (!SWIG_IsOK(res1)) {
30905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30906 }
30907 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30908 if (obj1) {
30909 ecode2 = SWIG_AsVal_int(obj1, &val2);
30910 if (!SWIG_IsOK(ecode2)) {
30911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30912 }
30913 arg2 = static_cast< wxDataObject::Direction >(val2);
30914 }
30915 {
30916 PyThreadState* __tstate = wxPyBeginAllowThreads();
30917 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30918 wxPyEndAllowThreads(__tstate);
30919 if (PyErr_Occurred()) SWIG_fail;
30920 }
30921 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30922 return resultobj;
30923 fail:
30924 return NULL;
30925 }
30926
30927
30928 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30929 PyObject *resultobj = 0;
30930 wxDataObject *arg1 = (wxDataObject *) 0 ;
30931 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30932 size_t result;
30933 void *argp1 = 0 ;
30934 int res1 = 0 ;
30935 int val2 ;
30936 int ecode2 = 0 ;
30937 PyObject * obj0 = 0 ;
30938 PyObject * obj1 = 0 ;
30939 char * kwnames[] = {
30940 (char *) "self",(char *) "dir", NULL
30941 };
30942
30943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30945 if (!SWIG_IsOK(res1)) {
30946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30947 }
30948 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30949 if (obj1) {
30950 ecode2 = SWIG_AsVal_int(obj1, &val2);
30951 if (!SWIG_IsOK(ecode2)) {
30952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30953 }
30954 arg2 = static_cast< wxDataObject::Direction >(val2);
30955 }
30956 {
30957 PyThreadState* __tstate = wxPyBeginAllowThreads();
30958 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30959 wxPyEndAllowThreads(__tstate);
30960 if (PyErr_Occurred()) SWIG_fail;
30961 }
30962 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30963 return resultobj;
30964 fail:
30965 return NULL;
30966 }
30967
30968
30969 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30970 PyObject *resultobj = 0;
30971 wxDataObject *arg1 = (wxDataObject *) 0 ;
30972 wxDataFormat *arg2 = 0 ;
30973 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30974 bool result;
30975 void *argp1 = 0 ;
30976 int res1 = 0 ;
30977 void *argp2 = 0 ;
30978 int res2 = 0 ;
30979 int val3 ;
30980 int ecode3 = 0 ;
30981 PyObject * obj0 = 0 ;
30982 PyObject * obj1 = 0 ;
30983 PyObject * obj2 = 0 ;
30984 char * kwnames[] = {
30985 (char *) "self",(char *) "format",(char *) "dir", NULL
30986 };
30987
30988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30990 if (!SWIG_IsOK(res1)) {
30991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30992 }
30993 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30994 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30995 if (!SWIG_IsOK(res2)) {
30996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30997 }
30998 if (!argp2) {
30999 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31000 }
31001 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31002 if (obj2) {
31003 ecode3 = SWIG_AsVal_int(obj2, &val3);
31004 if (!SWIG_IsOK(ecode3)) {
31005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31006 }
31007 arg3 = static_cast< wxDataObject::Direction >(val3);
31008 }
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 {
31016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31017 }
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj = 0;
31026 wxDataObject *arg1 = (wxDataObject *) 0 ;
31027 wxDataFormat *arg2 = 0 ;
31028 size_t result;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 void *argp2 = 0 ;
31032 int res2 = 0 ;
31033 PyObject * obj0 = 0 ;
31034 PyObject * obj1 = 0 ;
31035 char * kwnames[] = {
31036 (char *) "self",(char *) "format", NULL
31037 };
31038
31039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31041 if (!SWIG_IsOK(res1)) {
31042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31043 }
31044 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31045 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31046 if (!SWIG_IsOK(res2)) {
31047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31048 }
31049 if (!argp2) {
31050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31051 }
31052 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31053 {
31054 PyThreadState* __tstate = wxPyBeginAllowThreads();
31055 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31056 wxPyEndAllowThreads(__tstate);
31057 if (PyErr_Occurred()) SWIG_fail;
31058 }
31059 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31060 return resultobj;
31061 fail:
31062 return NULL;
31063 }
31064
31065
31066 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31067 PyObject *resultobj = 0;
31068 wxDataObject *arg1 = (wxDataObject *) 0 ;
31069 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31070 PyObject *result = 0 ;
31071 void *argp1 = 0 ;
31072 int res1 = 0 ;
31073 int val2 ;
31074 int ecode2 = 0 ;
31075 PyObject * obj0 = 0 ;
31076 PyObject * obj1 = 0 ;
31077 char * kwnames[] = {
31078 (char *) "self",(char *) "dir", NULL
31079 };
31080
31081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31085 }
31086 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31087 if (obj1) {
31088 ecode2 = SWIG_AsVal_int(obj1, &val2);
31089 if (!SWIG_IsOK(ecode2)) {
31090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31091 }
31092 arg2 = static_cast< wxDataObject::Direction >(val2);
31093 }
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31097 wxPyEndAllowThreads(__tstate);
31098 if (PyErr_Occurred()) SWIG_fail;
31099 }
31100 resultobj = result;
31101 return resultobj;
31102 fail:
31103 return NULL;
31104 }
31105
31106
31107 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31108 PyObject *resultobj = 0;
31109 wxDataObject *arg1 = (wxDataObject *) 0 ;
31110 wxDataFormat *arg2 = 0 ;
31111 PyObject *result = 0 ;
31112 void *argp1 = 0 ;
31113 int res1 = 0 ;
31114 void *argp2 = 0 ;
31115 int res2 = 0 ;
31116 PyObject * obj0 = 0 ;
31117 PyObject * obj1 = 0 ;
31118 char * kwnames[] = {
31119 (char *) "self",(char *) "format", NULL
31120 };
31121
31122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
31123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31124 if (!SWIG_IsOK(res1)) {
31125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
31126 }
31127 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31129 if (!SWIG_IsOK(res2)) {
31130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31131 }
31132 if (!argp2) {
31133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31134 }
31135 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31136 {
31137 PyThreadState* __tstate = wxPyBeginAllowThreads();
31138 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
31139 wxPyEndAllowThreads(__tstate);
31140 if (PyErr_Occurred()) SWIG_fail;
31141 }
31142 resultobj = result;
31143 return resultobj;
31144 fail:
31145 return NULL;
31146 }
31147
31148
31149 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31150 PyObject *resultobj = 0;
31151 wxDataObject *arg1 = (wxDataObject *) 0 ;
31152 wxDataFormat *arg2 = 0 ;
31153 PyObject *arg3 = (PyObject *) 0 ;
31154 bool result;
31155 void *argp1 = 0 ;
31156 int res1 = 0 ;
31157 void *argp2 = 0 ;
31158 int res2 = 0 ;
31159 PyObject * obj0 = 0 ;
31160 PyObject * obj1 = 0 ;
31161 PyObject * obj2 = 0 ;
31162 char * kwnames[] = {
31163 (char *) "self",(char *) "format",(char *) "data", NULL
31164 };
31165
31166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31168 if (!SWIG_IsOK(res1)) {
31169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
31170 }
31171 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31173 if (!SWIG_IsOK(res2)) {
31174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31175 }
31176 if (!argp2) {
31177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31178 }
31179 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31180 arg3 = obj2;
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 {
31188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31189 }
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31197 PyObject *obj;
31198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31199 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31200 return SWIG_Py_Void();
31201 }
31202
31203 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31204 PyObject *resultobj = 0;
31205 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31206 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31207 wxDataObjectSimple *result = 0 ;
31208 void *argp1 = 0 ;
31209 int res1 = 0 ;
31210 PyObject * obj0 = 0 ;
31211 char * kwnames[] = {
31212 (char *) "format", NULL
31213 };
31214
31215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31216 if (obj0) {
31217 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31218 if (!SWIG_IsOK(res1)) {
31219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31220 }
31221 if (!argp1) {
31222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31223 }
31224 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31225 }
31226 {
31227 PyThreadState* __tstate = wxPyBeginAllowThreads();
31228 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31229 wxPyEndAllowThreads(__tstate);
31230 if (PyErr_Occurred()) SWIG_fail;
31231 }
31232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31233 return resultobj;
31234 fail:
31235 return NULL;
31236 }
31237
31238
31239 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31240 PyObject *resultobj = 0;
31241 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31242 wxDataFormat *result = 0 ;
31243 void *argp1 = 0 ;
31244 int res1 = 0 ;
31245 PyObject *swig_obj[1] ;
31246
31247 if (!args) SWIG_fail;
31248 swig_obj[0] = args;
31249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31250 if (!SWIG_IsOK(res1)) {
31251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31252 }
31253 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 {
31257 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31258 result = (wxDataFormat *) &_result_ref;
31259 }
31260 wxPyEndAllowThreads(__tstate);
31261 if (PyErr_Occurred()) SWIG_fail;
31262 }
31263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31264 return resultobj;
31265 fail:
31266 return NULL;
31267 }
31268
31269
31270 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31271 PyObject *resultobj = 0;
31272 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31273 wxDataFormat *arg2 = 0 ;
31274 void *argp1 = 0 ;
31275 int res1 = 0 ;
31276 void *argp2 = 0 ;
31277 int res2 = 0 ;
31278 PyObject * obj0 = 0 ;
31279 PyObject * obj1 = 0 ;
31280 char * kwnames[] = {
31281 (char *) "self",(char *) "format", NULL
31282 };
31283
31284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31286 if (!SWIG_IsOK(res1)) {
31287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31288 }
31289 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31290 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31291 if (!SWIG_IsOK(res2)) {
31292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31293 }
31294 if (!argp2) {
31295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31296 }
31297 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31298 {
31299 PyThreadState* __tstate = wxPyBeginAllowThreads();
31300 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 resultobj = SWIG_Py_Void();
31305 return resultobj;
31306 fail:
31307 return NULL;
31308 }
31309
31310
31311 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31312 PyObject *resultobj = 0;
31313 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31314 size_t result;
31315 void *argp1 = 0 ;
31316 int res1 = 0 ;
31317 PyObject *swig_obj[1] ;
31318
31319 if (!args) SWIG_fail;
31320 swig_obj[0] = args;
31321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31322 if (!SWIG_IsOK(res1)) {
31323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31324 }
31325 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31329 wxPyEndAllowThreads(__tstate);
31330 if (PyErr_Occurred()) SWIG_fail;
31331 }
31332 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31333 return resultobj;
31334 fail:
31335 return NULL;
31336 }
31337
31338
31339 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31340 PyObject *resultobj = 0;
31341 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31342 PyObject *result = 0 ;
31343 void *argp1 = 0 ;
31344 int res1 = 0 ;
31345 PyObject *swig_obj[1] ;
31346
31347 if (!args) SWIG_fail;
31348 swig_obj[0] = args;
31349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31350 if (!SWIG_IsOK(res1)) {
31351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31352 }
31353 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 resultobj = result;
31361 return resultobj;
31362 fail:
31363 return NULL;
31364 }
31365
31366
31367 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31368 PyObject *resultobj = 0;
31369 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31370 PyObject *arg2 = (PyObject *) 0 ;
31371 bool result;
31372 void *argp1 = 0 ;
31373 int res1 = 0 ;
31374 PyObject * obj0 = 0 ;
31375 PyObject * obj1 = 0 ;
31376 char * kwnames[] = {
31377 (char *) "self",(char *) "data", NULL
31378 };
31379
31380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31382 if (!SWIG_IsOK(res1)) {
31383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31384 }
31385 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31386 arg2 = obj1;
31387 {
31388 PyThreadState* __tstate = wxPyBeginAllowThreads();
31389 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31390 wxPyEndAllowThreads(__tstate);
31391 if (PyErr_Occurred()) SWIG_fail;
31392 }
31393 {
31394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31395 }
31396 return resultobj;
31397 fail:
31398 return NULL;
31399 }
31400
31401
31402 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31403 PyObject *obj;
31404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31405 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31406 return SWIG_Py_Void();
31407 }
31408
31409 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31410 return SWIG_Python_InitShadowInstance(args);
31411 }
31412
31413 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31414 PyObject *resultobj = 0;
31415 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31416 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31417 wxPyDataObjectSimple *result = 0 ;
31418 void *argp1 = 0 ;
31419 int res1 = 0 ;
31420 PyObject * obj0 = 0 ;
31421 char * kwnames[] = {
31422 (char *) "format", NULL
31423 };
31424
31425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31426 if (obj0) {
31427 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31428 if (!SWIG_IsOK(res1)) {
31429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31430 }
31431 if (!argp1) {
31432 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31433 }
31434 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31435 }
31436 {
31437 PyThreadState* __tstate = wxPyBeginAllowThreads();
31438 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31439 wxPyEndAllowThreads(__tstate);
31440 if (PyErr_Occurred()) SWIG_fail;
31441 }
31442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31443 return resultobj;
31444 fail:
31445 return NULL;
31446 }
31447
31448
31449 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31450 PyObject *resultobj = 0;
31451 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31452 PyObject *arg2 = (PyObject *) 0 ;
31453 PyObject *arg3 = (PyObject *) 0 ;
31454 void *argp1 = 0 ;
31455 int res1 = 0 ;
31456 PyObject * obj0 = 0 ;
31457 PyObject * obj1 = 0 ;
31458 PyObject * obj2 = 0 ;
31459 char * kwnames[] = {
31460 (char *) "self",(char *) "self",(char *) "_class", NULL
31461 };
31462
31463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31465 if (!SWIG_IsOK(res1)) {
31466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31467 }
31468 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31469 arg2 = obj1;
31470 arg3 = obj2;
31471 {
31472 PyThreadState* __tstate = wxPyBeginAllowThreads();
31473 (arg1)->_setCallbackInfo(arg2,arg3);
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 resultobj = SWIG_Py_Void();
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31485 PyObject *obj;
31486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31487 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31488 return SWIG_Py_Void();
31489 }
31490
31491 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31492 return SWIG_Python_InitShadowInstance(args);
31493 }
31494
31495 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31496 PyObject *resultobj = 0;
31497 wxDataObjectComposite *result = 0 ;
31498
31499 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31500 {
31501 PyThreadState* __tstate = wxPyBeginAllowThreads();
31502 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31503 wxPyEndAllowThreads(__tstate);
31504 if (PyErr_Occurred()) SWIG_fail;
31505 }
31506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31507 return resultobj;
31508 fail:
31509 return NULL;
31510 }
31511
31512
31513 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31514 PyObject *resultobj = 0;
31515 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31516 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31517 bool arg3 = (bool) false ;
31518 void *argp1 = 0 ;
31519 int res1 = 0 ;
31520 int res2 = 0 ;
31521 bool val3 ;
31522 int ecode3 = 0 ;
31523 PyObject * obj0 = 0 ;
31524 PyObject * obj1 = 0 ;
31525 PyObject * obj2 = 0 ;
31526 char * kwnames[] = {
31527 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31528 };
31529
31530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31532 if (!SWIG_IsOK(res1)) {
31533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31534 }
31535 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31536 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31537 if (!SWIG_IsOK(res2)) {
31538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31539 }
31540 if (obj2) {
31541 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31542 if (!SWIG_IsOK(ecode3)) {
31543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31544 }
31545 arg3 = static_cast< bool >(val3);
31546 }
31547 {
31548 PyThreadState* __tstate = wxPyBeginAllowThreads();
31549 (arg1)->Add(arg2,arg3);
31550 wxPyEndAllowThreads(__tstate);
31551 if (PyErr_Occurred()) SWIG_fail;
31552 }
31553 resultobj = SWIG_Py_Void();
31554 return resultobj;
31555 fail:
31556 return NULL;
31557 }
31558
31559
31560 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31561 PyObject *resultobj = 0;
31562 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31563 SwigValueWrapper<wxDataFormat > result;
31564 void *argp1 = 0 ;
31565 int res1 = 0 ;
31566 PyObject *swig_obj[1] ;
31567
31568 if (!args) SWIG_fail;
31569 swig_obj[0] = args;
31570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31571 if (!SWIG_IsOK(res1)) {
31572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31573 }
31574 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31575 {
31576 PyThreadState* __tstate = wxPyBeginAllowThreads();
31577 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31578 wxPyEndAllowThreads(__tstate);
31579 if (PyErr_Occurred()) SWIG_fail;
31580 }
31581 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31589 PyObject *obj;
31590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31591 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31592 return SWIG_Py_Void();
31593 }
31594
31595 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31596 return SWIG_Python_InitShadowInstance(args);
31597 }
31598
31599 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31600 PyObject *resultobj = 0;
31601 wxString const &arg1_defvalue = wxPyEmptyString ;
31602 wxString *arg1 = (wxString *) &arg1_defvalue ;
31603 wxTextDataObject *result = 0 ;
31604 bool temp1 = false ;
31605 PyObject * obj0 = 0 ;
31606 char * kwnames[] = {
31607 (char *) "text", NULL
31608 };
31609
31610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31611 if (obj0) {
31612 {
31613 arg1 = wxString_in_helper(obj0);
31614 if (arg1 == NULL) SWIG_fail;
31615 temp1 = true;
31616 }
31617 }
31618 {
31619 PyThreadState* __tstate = wxPyBeginAllowThreads();
31620 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31621 wxPyEndAllowThreads(__tstate);
31622 if (PyErr_Occurred()) SWIG_fail;
31623 }
31624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31625 {
31626 if (temp1)
31627 delete arg1;
31628 }
31629 return resultobj;
31630 fail:
31631 {
31632 if (temp1)
31633 delete arg1;
31634 }
31635 return NULL;
31636 }
31637
31638
31639 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31640 PyObject *resultobj = 0;
31641 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31642 size_t result;
31643 void *argp1 = 0 ;
31644 int res1 = 0 ;
31645 PyObject *swig_obj[1] ;
31646
31647 if (!args) SWIG_fail;
31648 swig_obj[0] = args;
31649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31650 if (!SWIG_IsOK(res1)) {
31651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31652 }
31653 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31654 {
31655 PyThreadState* __tstate = wxPyBeginAllowThreads();
31656 result = (size_t)(arg1)->GetTextLength();
31657 wxPyEndAllowThreads(__tstate);
31658 if (PyErr_Occurred()) SWIG_fail;
31659 }
31660 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31661 return resultobj;
31662 fail:
31663 return NULL;
31664 }
31665
31666
31667 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31668 PyObject *resultobj = 0;
31669 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31670 wxString result;
31671 void *argp1 = 0 ;
31672 int res1 = 0 ;
31673 PyObject *swig_obj[1] ;
31674
31675 if (!args) SWIG_fail;
31676 swig_obj[0] = args;
31677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31678 if (!SWIG_IsOK(res1)) {
31679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31680 }
31681 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31682 {
31683 PyThreadState* __tstate = wxPyBeginAllowThreads();
31684 result = (arg1)->GetText();
31685 wxPyEndAllowThreads(__tstate);
31686 if (PyErr_Occurred()) SWIG_fail;
31687 }
31688 {
31689 #if wxUSE_UNICODE
31690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31691 #else
31692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31693 #endif
31694 }
31695 return resultobj;
31696 fail:
31697 return NULL;
31698 }
31699
31700
31701 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31702 PyObject *resultobj = 0;
31703 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31704 wxString *arg2 = 0 ;
31705 void *argp1 = 0 ;
31706 int res1 = 0 ;
31707 bool temp2 = false ;
31708 PyObject * obj0 = 0 ;
31709 PyObject * obj1 = 0 ;
31710 char * kwnames[] = {
31711 (char *) "self",(char *) "text", NULL
31712 };
31713
31714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31716 if (!SWIG_IsOK(res1)) {
31717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31718 }
31719 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31720 {
31721 arg2 = wxString_in_helper(obj1);
31722 if (arg2 == NULL) SWIG_fail;
31723 temp2 = true;
31724 }
31725 {
31726 PyThreadState* __tstate = wxPyBeginAllowThreads();
31727 (arg1)->SetText((wxString const &)*arg2);
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 resultobj = SWIG_Py_Void();
31732 {
31733 if (temp2)
31734 delete arg2;
31735 }
31736 return resultobj;
31737 fail:
31738 {
31739 if (temp2)
31740 delete arg2;
31741 }
31742 return NULL;
31743 }
31744
31745
31746 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31747 PyObject *obj;
31748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31749 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31750 return SWIG_Py_Void();
31751 }
31752
31753 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31754 return SWIG_Python_InitShadowInstance(args);
31755 }
31756
31757 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31758 PyObject *resultobj = 0;
31759 wxString const &arg1_defvalue = wxPyEmptyString ;
31760 wxString *arg1 = (wxString *) &arg1_defvalue ;
31761 wxPyTextDataObject *result = 0 ;
31762 bool temp1 = false ;
31763 PyObject * obj0 = 0 ;
31764 char * kwnames[] = {
31765 (char *) "text", NULL
31766 };
31767
31768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31769 if (obj0) {
31770 {
31771 arg1 = wxString_in_helper(obj0);
31772 if (arg1 == NULL) SWIG_fail;
31773 temp1 = true;
31774 }
31775 }
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31783 {
31784 if (temp1)
31785 delete arg1;
31786 }
31787 return resultobj;
31788 fail:
31789 {
31790 if (temp1)
31791 delete arg1;
31792 }
31793 return NULL;
31794 }
31795
31796
31797 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31798 PyObject *resultobj = 0;
31799 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31800 PyObject *arg2 = (PyObject *) 0 ;
31801 PyObject *arg3 = (PyObject *) 0 ;
31802 void *argp1 = 0 ;
31803 int res1 = 0 ;
31804 PyObject * obj0 = 0 ;
31805 PyObject * obj1 = 0 ;
31806 PyObject * obj2 = 0 ;
31807 char * kwnames[] = {
31808 (char *) "self",(char *) "self",(char *) "_class", NULL
31809 };
31810
31811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31813 if (!SWIG_IsOK(res1)) {
31814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31815 }
31816 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31817 arg2 = obj1;
31818 arg3 = obj2;
31819 {
31820 PyThreadState* __tstate = wxPyBeginAllowThreads();
31821 (arg1)->_setCallbackInfo(arg2,arg3);
31822 wxPyEndAllowThreads(__tstate);
31823 if (PyErr_Occurred()) SWIG_fail;
31824 }
31825 resultobj = SWIG_Py_Void();
31826 return resultobj;
31827 fail:
31828 return NULL;
31829 }
31830
31831
31832 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31833 PyObject *obj;
31834 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31835 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31836 return SWIG_Py_Void();
31837 }
31838
31839 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31840 return SWIG_Python_InitShadowInstance(args);
31841 }
31842
31843 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31844 PyObject *resultobj = 0;
31845 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31846 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31847 wxBitmapDataObject *result = 0 ;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 PyObject * obj0 = 0 ;
31851 char * kwnames[] = {
31852 (char *) "bitmap", NULL
31853 };
31854
31855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31856 if (obj0) {
31857 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31858 if (!SWIG_IsOK(res1)) {
31859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31860 }
31861 if (!argp1) {
31862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31863 }
31864 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31865 }
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *resultobj = 0;
31881 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31882 wxBitmap result;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 PyObject *swig_obj[1] ;
31886
31887 if (!args) SWIG_fail;
31888 swig_obj[0] = args;
31889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31892 }
31893 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31901 return resultobj;
31902 fail:
31903 return NULL;
31904 }
31905
31906
31907 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31908 PyObject *resultobj = 0;
31909 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31910 wxBitmap *arg2 = 0 ;
31911 void *argp1 = 0 ;
31912 int res1 = 0 ;
31913 void *argp2 = 0 ;
31914 int res2 = 0 ;
31915 PyObject * obj0 = 0 ;
31916 PyObject * obj1 = 0 ;
31917 char * kwnames[] = {
31918 (char *) "self",(char *) "bitmap", NULL
31919 };
31920
31921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31923 if (!SWIG_IsOK(res1)) {
31924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31925 }
31926 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31928 if (!SWIG_IsOK(res2)) {
31929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31930 }
31931 if (!argp2) {
31932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31933 }
31934 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31935 {
31936 PyThreadState* __tstate = wxPyBeginAllowThreads();
31937 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31938 wxPyEndAllowThreads(__tstate);
31939 if (PyErr_Occurred()) SWIG_fail;
31940 }
31941 resultobj = SWIG_Py_Void();
31942 return resultobj;
31943 fail:
31944 return NULL;
31945 }
31946
31947
31948 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31949 PyObject *obj;
31950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31951 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31952 return SWIG_Py_Void();
31953 }
31954
31955 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31956 return SWIG_Python_InitShadowInstance(args);
31957 }
31958
31959 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31960 PyObject *resultobj = 0;
31961 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31962 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31963 wxPyBitmapDataObject *result = 0 ;
31964 void *argp1 = 0 ;
31965 int res1 = 0 ;
31966 PyObject * obj0 = 0 ;
31967 char * kwnames[] = {
31968 (char *) "bitmap", NULL
31969 };
31970
31971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31972 if (obj0) {
31973 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31974 if (!SWIG_IsOK(res1)) {
31975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31976 }
31977 if (!argp1) {
31978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31979 }
31980 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31981 }
31982 {
31983 PyThreadState* __tstate = wxPyBeginAllowThreads();
31984 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31985 wxPyEndAllowThreads(__tstate);
31986 if (PyErr_Occurred()) SWIG_fail;
31987 }
31988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31989 return resultobj;
31990 fail:
31991 return NULL;
31992 }
31993
31994
31995 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31996 PyObject *resultobj = 0;
31997 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31998 PyObject *arg2 = (PyObject *) 0 ;
31999 PyObject *arg3 = (PyObject *) 0 ;
32000 void *argp1 = 0 ;
32001 int res1 = 0 ;
32002 PyObject * obj0 = 0 ;
32003 PyObject * obj1 = 0 ;
32004 PyObject * obj2 = 0 ;
32005 char * kwnames[] = {
32006 (char *) "self",(char *) "self",(char *) "_class", NULL
32007 };
32008
32009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32011 if (!SWIG_IsOK(res1)) {
32012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32013 }
32014 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32015 arg2 = obj1;
32016 arg3 = obj2;
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 (arg1)->_setCallbackInfo(arg2,arg3);
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_Py_Void();
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32031 PyObject *obj;
32032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32033 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32034 return SWIG_Py_Void();
32035 }
32036
32037 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32038 return SWIG_Python_InitShadowInstance(args);
32039 }
32040
32041 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32042 PyObject *resultobj = 0;
32043 wxFileDataObject *result = 0 ;
32044
32045 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
32046 {
32047 PyThreadState* __tstate = wxPyBeginAllowThreads();
32048 result = (wxFileDataObject *)new wxFileDataObject();
32049 wxPyEndAllowThreads(__tstate);
32050 if (PyErr_Occurred()) SWIG_fail;
32051 }
32052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32053 return resultobj;
32054 fail:
32055 return NULL;
32056 }
32057
32058
32059 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32060 PyObject *resultobj = 0;
32061 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32062 wxArrayString *result = 0 ;
32063 void *argp1 = 0 ;
32064 int res1 = 0 ;
32065 PyObject *swig_obj[1] ;
32066
32067 if (!args) SWIG_fail;
32068 swig_obj[0] = args;
32069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32070 if (!SWIG_IsOK(res1)) {
32071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32072 }
32073 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32074 {
32075 PyThreadState* __tstate = wxPyBeginAllowThreads();
32076 {
32077 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32078 result = (wxArrayString *) &_result_ref;
32079 }
32080 wxPyEndAllowThreads(__tstate);
32081 if (PyErr_Occurred()) SWIG_fail;
32082 }
32083 {
32084 resultobj = wxArrayString2PyList_helper(*result);
32085 }
32086 return resultobj;
32087 fail:
32088 return NULL;
32089 }
32090
32091
32092 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32093 PyObject *resultobj = 0;
32094 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32095 wxString *arg2 = 0 ;
32096 void *argp1 = 0 ;
32097 int res1 = 0 ;
32098 bool temp2 = false ;
32099 PyObject * obj0 = 0 ;
32100 PyObject * obj1 = 0 ;
32101 char * kwnames[] = {
32102 (char *) "self",(char *) "filename", NULL
32103 };
32104
32105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
32106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32107 if (!SWIG_IsOK(res1)) {
32108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32109 }
32110 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32111 {
32112 arg2 = wxString_in_helper(obj1);
32113 if (arg2 == NULL) SWIG_fail;
32114 temp2 = true;
32115 }
32116 {
32117 PyThreadState* __tstate = wxPyBeginAllowThreads();
32118 (arg1)->AddFile((wxString const &)*arg2);
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 resultobj = SWIG_Py_Void();
32123 {
32124 if (temp2)
32125 delete arg2;
32126 }
32127 return resultobj;
32128 fail:
32129 {
32130 if (temp2)
32131 delete arg2;
32132 }
32133 return NULL;
32134 }
32135
32136
32137 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32138 PyObject *obj;
32139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32140 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
32141 return SWIG_Py_Void();
32142 }
32143
32144 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 return SWIG_Python_InitShadowInstance(args);
32146 }
32147
32148 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32149 PyObject *resultobj = 0;
32150 wxDataFormat *arg1 = 0 ;
32151 wxCustomDataObject *result = 0 ;
32152 void *argp1 = 0 ;
32153 int res1 = 0 ;
32154
32155 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32157 if (!SWIG_IsOK(res1)) {
32158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32159 }
32160 if (!argp1) {
32161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32162 }
32163 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
32167 wxPyEndAllowThreads(__tstate);
32168 if (PyErr_Occurred()) SWIG_fail;
32169 }
32170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32171 return resultobj;
32172 fail:
32173 return NULL;
32174 }
32175
32176
32177 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32178 PyObject *resultobj = 0;
32179 wxString *arg1 = 0 ;
32180 wxCustomDataObject *result = 0 ;
32181 bool temp1 = false ;
32182
32183 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32184 {
32185 arg1 = wxString_in_helper(swig_obj[0]);
32186 if (arg1 == NULL) SWIG_fail;
32187 temp1 = true;
32188 }
32189 {
32190 PyThreadState* __tstate = wxPyBeginAllowThreads();
32191 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32192 wxPyEndAllowThreads(__tstate);
32193 if (PyErr_Occurred()) SWIG_fail;
32194 }
32195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32196 {
32197 if (temp1)
32198 delete arg1;
32199 }
32200 return resultobj;
32201 fail:
32202 {
32203 if (temp1)
32204 delete arg1;
32205 }
32206 return NULL;
32207 }
32208
32209
32210 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32211 PyObject *resultobj = 0;
32212 wxCustomDataObject *result = 0 ;
32213
32214 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (wxCustomDataObject *)new wxCustomDataObject();
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32222 return resultobj;
32223 fail:
32224 return NULL;
32225 }
32226
32227
32228 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32229 int argc;
32230 PyObject *argv[2];
32231
32232 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32233 --argc;
32234 if (argc == 0) {
32235 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32236 }
32237 if (argc == 1) {
32238 int _v = 0;
32239 {
32240 {
32241 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32242 }
32243 }
32244 if (!_v) goto check_2;
32245 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32246 }
32247 check_2:
32248
32249 if (argc == 1) {
32250 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32251 }
32252
32253 fail:
32254 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32255 return NULL;
32256 }
32257
32258
32259 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32260 PyObject *resultobj = 0;
32261 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32262 PyObject *arg2 = (PyObject *) 0 ;
32263 bool result;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 PyObject * obj0 = 0 ;
32267 PyObject * obj1 = 0 ;
32268 char * kwnames[] = {
32269 (char *) "self",(char *) "data", NULL
32270 };
32271
32272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32274 if (!SWIG_IsOK(res1)) {
32275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32276 }
32277 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32278 arg2 = obj1;
32279 {
32280 PyThreadState* __tstate = wxPyBeginAllowThreads();
32281 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32282 wxPyEndAllowThreads(__tstate);
32283 if (PyErr_Occurred()) SWIG_fail;
32284 }
32285 {
32286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32287 }
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 PyObject *resultobj = 0;
32296 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32297 size_t result;
32298 void *argp1 = 0 ;
32299 int res1 = 0 ;
32300 PyObject *swig_obj[1] ;
32301
32302 if (!args) SWIG_fail;
32303 swig_obj[0] = args;
32304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32305 if (!SWIG_IsOK(res1)) {
32306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32307 }
32308 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 result = (size_t)(arg1)->GetSize();
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 PyObject *resultobj = 0;
32324 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32325 PyObject *result = 0 ;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 PyObject *swig_obj[1] ;
32329
32330 if (!args) SWIG_fail;
32331 swig_obj[0] = args;
32332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32335 }
32336 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 resultobj = result;
32344 return resultobj;
32345 fail:
32346 return NULL;
32347 }
32348
32349
32350 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32351 PyObject *obj;
32352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32353 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32354 return SWIG_Py_Void();
32355 }
32356
32357 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32358 return SWIG_Python_InitShadowInstance(args);
32359 }
32360
32361 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32362 PyObject *resultobj = 0;
32363 wxURLDataObject *result = 0 ;
32364
32365 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 result = (wxURLDataObject *)new wxURLDataObject();
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32373 return resultobj;
32374 fail:
32375 return NULL;
32376 }
32377
32378
32379 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 PyObject *resultobj = 0;
32381 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32382 wxString result;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 PyObject *swig_obj[1] ;
32386
32387 if (!args) SWIG_fail;
32388 swig_obj[0] = args;
32389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32390 if (!SWIG_IsOK(res1)) {
32391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32392 }
32393 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32394 {
32395 PyThreadState* __tstate = wxPyBeginAllowThreads();
32396 result = (arg1)->GetURL();
32397 wxPyEndAllowThreads(__tstate);
32398 if (PyErr_Occurred()) SWIG_fail;
32399 }
32400 {
32401 #if wxUSE_UNICODE
32402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32403 #else
32404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32405 #endif
32406 }
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj = 0;
32415 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32416 wxString *arg2 = 0 ;
32417 void *argp1 = 0 ;
32418 int res1 = 0 ;
32419 bool temp2 = false ;
32420 PyObject * obj0 = 0 ;
32421 PyObject * obj1 = 0 ;
32422 char * kwnames[] = {
32423 (char *) "self",(char *) "url", NULL
32424 };
32425
32426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32428 if (!SWIG_IsOK(res1)) {
32429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32430 }
32431 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32432 {
32433 arg2 = wxString_in_helper(obj1);
32434 if (arg2 == NULL) SWIG_fail;
32435 temp2 = true;
32436 }
32437 {
32438 PyThreadState* __tstate = wxPyBeginAllowThreads();
32439 (arg1)->SetURL((wxString const &)*arg2);
32440 wxPyEndAllowThreads(__tstate);
32441 if (PyErr_Occurred()) SWIG_fail;
32442 }
32443 resultobj = SWIG_Py_Void();
32444 {
32445 if (temp2)
32446 delete arg2;
32447 }
32448 return resultobj;
32449 fail:
32450 {
32451 if (temp2)
32452 delete arg2;
32453 }
32454 return NULL;
32455 }
32456
32457
32458 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32459 PyObject *obj;
32460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32461 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32462 return SWIG_Py_Void();
32463 }
32464
32465 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32466 return SWIG_Python_InitShadowInstance(args);
32467 }
32468
32469 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32470 PyObject *resultobj = 0;
32471 wxMetafileDataObject *result = 0 ;
32472
32473 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32477 wxPyEndAllowThreads(__tstate);
32478 if (PyErr_Occurred()) SWIG_fail;
32479 }
32480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32481 return resultobj;
32482 fail:
32483 return NULL;
32484 }
32485
32486
32487 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32488 PyObject *resultobj = 0;
32489 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32490 wxMetafile *arg2 = 0 ;
32491 void *argp1 = 0 ;
32492 int res1 = 0 ;
32493 void *argp2 = 0 ;
32494 int res2 = 0 ;
32495 PyObject * obj0 = 0 ;
32496 PyObject * obj1 = 0 ;
32497 char * kwnames[] = {
32498 (char *) "self",(char *) "metafile", NULL
32499 };
32500
32501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32503 if (!SWIG_IsOK(res1)) {
32504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32505 }
32506 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32507 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32508 if (!SWIG_IsOK(res2)) {
32509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32510 }
32511 if (!argp2) {
32512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32513 }
32514 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 resultobj = SWIG_Py_Void();
32522 return resultobj;
32523 fail:
32524 return NULL;
32525 }
32526
32527
32528 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32529 PyObject *resultobj = 0;
32530 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32531 wxMetafile result;
32532 void *argp1 = 0 ;
32533 int res1 = 0 ;
32534 PyObject *swig_obj[1] ;
32535
32536 if (!args) SWIG_fail;
32537 swig_obj[0] = args;
32538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32539 if (!SWIG_IsOK(res1)) {
32540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32541 }
32542 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32543 {
32544 PyThreadState* __tstate = wxPyBeginAllowThreads();
32545 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32546 wxPyEndAllowThreads(__tstate);
32547 if (PyErr_Occurred()) SWIG_fail;
32548 }
32549 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32557 PyObject *obj;
32558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32559 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32560 return SWIG_Py_Void();
32561 }
32562
32563 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32564 return SWIG_Python_InitShadowInstance(args);
32565 }
32566
32567 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32568 PyObject *resultobj = 0;
32569 wxDragResult arg1 ;
32570 bool result;
32571 int val1 ;
32572 int ecode1 = 0 ;
32573 PyObject * obj0 = 0 ;
32574 char * kwnames[] = {
32575 (char *) "res", NULL
32576 };
32577
32578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32579 ecode1 = SWIG_AsVal_int(obj0, &val1);
32580 if (!SWIG_IsOK(ecode1)) {
32581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32582 }
32583 arg1 = static_cast< wxDragResult >(val1);
32584 {
32585 PyThreadState* __tstate = wxPyBeginAllowThreads();
32586 result = (bool)wxIsDragResultOk(arg1);
32587 wxPyEndAllowThreads(__tstate);
32588 if (PyErr_Occurred()) SWIG_fail;
32589 }
32590 {
32591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32592 }
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32600 PyObject *resultobj = 0;
32601 wxWindow *arg1 = (wxWindow *) 0 ;
32602 wxCursor const &arg2_defvalue = wxNullCursor ;
32603 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32604 wxCursor const &arg3_defvalue = wxNullCursor ;
32605 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32606 wxCursor const &arg4_defvalue = wxNullCursor ;
32607 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32608 wxPyDropSource *result = 0 ;
32609 void *argp1 = 0 ;
32610 int res1 = 0 ;
32611 void *argp2 = 0 ;
32612 int res2 = 0 ;
32613 void *argp3 = 0 ;
32614 int res3 = 0 ;
32615 void *argp4 = 0 ;
32616 int res4 = 0 ;
32617 PyObject * obj0 = 0 ;
32618 PyObject * obj1 = 0 ;
32619 PyObject * obj2 = 0 ;
32620 PyObject * obj3 = 0 ;
32621 char * kwnames[] = {
32622 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32623 };
32624
32625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32627 if (!SWIG_IsOK(res1)) {
32628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32629 }
32630 arg1 = reinterpret_cast< wxWindow * >(argp1);
32631 if (obj1) {
32632 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32633 if (!SWIG_IsOK(res2)) {
32634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32635 }
32636 if (!argp2) {
32637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32638 }
32639 arg2 = reinterpret_cast< wxCursor * >(argp2);
32640 }
32641 if (obj2) {
32642 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32643 if (!SWIG_IsOK(res3)) {
32644 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32645 }
32646 if (!argp3) {
32647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32648 }
32649 arg3 = reinterpret_cast< wxCursor * >(argp3);
32650 }
32651 if (obj3) {
32652 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32653 if (!SWIG_IsOK(res4)) {
32654 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32655 }
32656 if (!argp4) {
32657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32658 }
32659 arg4 = reinterpret_cast< wxCursor * >(argp4);
32660 }
32661 {
32662 PyThreadState* __tstate = wxPyBeginAllowThreads();
32663 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32664 wxPyEndAllowThreads(__tstate);
32665 if (PyErr_Occurred()) SWIG_fail;
32666 }
32667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32668 return resultobj;
32669 fail:
32670 return NULL;
32671 }
32672
32673
32674 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32675 PyObject *resultobj = 0;
32676 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32677 PyObject *arg2 = (PyObject *) 0 ;
32678 PyObject *arg3 = (PyObject *) 0 ;
32679 int arg4 ;
32680 void *argp1 = 0 ;
32681 int res1 = 0 ;
32682 int val4 ;
32683 int ecode4 = 0 ;
32684 PyObject * obj0 = 0 ;
32685 PyObject * obj1 = 0 ;
32686 PyObject * obj2 = 0 ;
32687 PyObject * obj3 = 0 ;
32688 char * kwnames[] = {
32689 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32690 };
32691
32692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32694 if (!SWIG_IsOK(res1)) {
32695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32696 }
32697 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32698 arg2 = obj1;
32699 arg3 = obj2;
32700 ecode4 = SWIG_AsVal_int(obj3, &val4);
32701 if (!SWIG_IsOK(ecode4)) {
32702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32703 }
32704 arg4 = static_cast< int >(val4);
32705 {
32706 PyThreadState* __tstate = wxPyBeginAllowThreads();
32707 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
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_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32719 PyObject *resultobj = 0;
32720 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32721 void *argp1 = 0 ;
32722 int res1 = 0 ;
32723 PyObject *swig_obj[1] ;
32724
32725 if (!args) SWIG_fail;
32726 swig_obj[0] = args;
32727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32728 if (!SWIG_IsOK(res1)) {
32729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32730 }
32731 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32732 {
32733 PyThreadState* __tstate = wxPyBeginAllowThreads();
32734 delete arg1;
32735
32736 wxPyEndAllowThreads(__tstate);
32737 if (PyErr_Occurred()) SWIG_fail;
32738 }
32739 resultobj = SWIG_Py_Void();
32740 return resultobj;
32741 fail:
32742 return NULL;
32743 }
32744
32745
32746 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32747 PyObject *resultobj = 0;
32748 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32749 wxDataObject *arg2 = 0 ;
32750 void *argp1 = 0 ;
32751 int res1 = 0 ;
32752 void *argp2 = 0 ;
32753 int res2 = 0 ;
32754 PyObject * obj0 = 0 ;
32755 PyObject * obj1 = 0 ;
32756 char * kwnames[] = {
32757 (char *) "self",(char *) "data", NULL
32758 };
32759
32760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32762 if (!SWIG_IsOK(res1)) {
32763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32764 }
32765 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32766 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32767 if (!SWIG_IsOK(res2)) {
32768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32769 }
32770 if (!argp2) {
32771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32772 }
32773 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32774 {
32775 PyThreadState* __tstate = wxPyBeginAllowThreads();
32776 (arg1)->SetData(*arg2);
32777 wxPyEndAllowThreads(__tstate);
32778 if (PyErr_Occurred()) SWIG_fail;
32779 }
32780 resultobj = SWIG_Py_Void();
32781 return resultobj;
32782 fail:
32783 return NULL;
32784 }
32785
32786
32787 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32788 PyObject *resultobj = 0;
32789 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32790 wxDataObject *result = 0 ;
32791 void *argp1 = 0 ;
32792 int res1 = 0 ;
32793 PyObject *swig_obj[1] ;
32794
32795 if (!args) SWIG_fail;
32796 swig_obj[0] = args;
32797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32798 if (!SWIG_IsOK(res1)) {
32799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32800 }
32801 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32802 {
32803 PyThreadState* __tstate = wxPyBeginAllowThreads();
32804 result = (wxDataObject *)(arg1)->GetDataObject();
32805 wxPyEndAllowThreads(__tstate);
32806 if (PyErr_Occurred()) SWIG_fail;
32807 }
32808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32809 return resultobj;
32810 fail:
32811 return NULL;
32812 }
32813
32814
32815 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32816 PyObject *resultobj = 0;
32817 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32818 wxDragResult arg2 ;
32819 wxCursor *arg3 = 0 ;
32820 void *argp1 = 0 ;
32821 int res1 = 0 ;
32822 int val2 ;
32823 int ecode2 = 0 ;
32824 void *argp3 = 0 ;
32825 int res3 = 0 ;
32826 PyObject * obj0 = 0 ;
32827 PyObject * obj1 = 0 ;
32828 PyObject * obj2 = 0 ;
32829 char * kwnames[] = {
32830 (char *) "self",(char *) "res",(char *) "cursor", NULL
32831 };
32832
32833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32835 if (!SWIG_IsOK(res1)) {
32836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32837 }
32838 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32839 ecode2 = SWIG_AsVal_int(obj1, &val2);
32840 if (!SWIG_IsOK(ecode2)) {
32841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32842 }
32843 arg2 = static_cast< wxDragResult >(val2);
32844 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32845 if (!SWIG_IsOK(res3)) {
32846 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32847 }
32848 if (!argp3) {
32849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32850 }
32851 arg3 = reinterpret_cast< wxCursor * >(argp3);
32852 {
32853 PyThreadState* __tstate = wxPyBeginAllowThreads();
32854 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32855 wxPyEndAllowThreads(__tstate);
32856 if (PyErr_Occurred()) SWIG_fail;
32857 }
32858 resultobj = SWIG_Py_Void();
32859 return resultobj;
32860 fail:
32861 return NULL;
32862 }
32863
32864
32865 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32866 PyObject *resultobj = 0;
32867 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32868 int arg2 = (int) wxDrag_CopyOnly ;
32869 wxDragResult result;
32870 void *argp1 = 0 ;
32871 int res1 = 0 ;
32872 int val2 ;
32873 int ecode2 = 0 ;
32874 PyObject * obj0 = 0 ;
32875 PyObject * obj1 = 0 ;
32876 char * kwnames[] = {
32877 (char *) "self",(char *) "flags", NULL
32878 };
32879
32880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32882 if (!SWIG_IsOK(res1)) {
32883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32884 }
32885 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32886 if (obj1) {
32887 ecode2 = SWIG_AsVal_int(obj1, &val2);
32888 if (!SWIG_IsOK(ecode2)) {
32889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32890 }
32891 arg2 = static_cast< int >(val2);
32892 }
32893 {
32894 PyThreadState* __tstate = wxPyBeginAllowThreads();
32895 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32896 wxPyEndAllowThreads(__tstate);
32897 if (PyErr_Occurred()) SWIG_fail;
32898 }
32899 resultobj = SWIG_From_int(static_cast< int >(result));
32900 return resultobj;
32901 fail:
32902 return NULL;
32903 }
32904
32905
32906 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32907 PyObject *resultobj = 0;
32908 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32909 wxDragResult arg2 ;
32910 bool result;
32911 void *argp1 = 0 ;
32912 int res1 = 0 ;
32913 int val2 ;
32914 int ecode2 = 0 ;
32915 PyObject * obj0 = 0 ;
32916 PyObject * obj1 = 0 ;
32917 char * kwnames[] = {
32918 (char *) "self",(char *) "effect", NULL
32919 };
32920
32921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32923 if (!SWIG_IsOK(res1)) {
32924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32925 }
32926 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32927 ecode2 = SWIG_AsVal_int(obj1, &val2);
32928 if (!SWIG_IsOK(ecode2)) {
32929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32930 }
32931 arg2 = static_cast< wxDragResult >(val2);
32932 {
32933 PyThreadState* __tstate = wxPyBeginAllowThreads();
32934 result = (bool)(arg1)->GiveFeedback(arg2);
32935 wxPyEndAllowThreads(__tstate);
32936 if (PyErr_Occurred()) SWIG_fail;
32937 }
32938 {
32939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32940 }
32941 return resultobj;
32942 fail:
32943 return NULL;
32944 }
32945
32946
32947 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32948 PyObject *obj;
32949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32950 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32951 return SWIG_Py_Void();
32952 }
32953
32954 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32955 return SWIG_Python_InitShadowInstance(args);
32956 }
32957
32958 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32959 PyObject *resultobj = 0;
32960 wxDataObject *arg1 = (wxDataObject *) NULL ;
32961 wxPyDropTarget *result = 0 ;
32962 int res1 = 0 ;
32963 PyObject * obj0 = 0 ;
32964 char * kwnames[] = {
32965 (char *) "dataObject", NULL
32966 };
32967
32968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32969 if (obj0) {
32970 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32971 if (!SWIG_IsOK(res1)) {
32972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32973 }
32974 }
32975 {
32976 PyThreadState* __tstate = wxPyBeginAllowThreads();
32977 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32978 wxPyEndAllowThreads(__tstate);
32979 if (PyErr_Occurred()) SWIG_fail;
32980 }
32981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32982 return resultobj;
32983 fail:
32984 return NULL;
32985 }
32986
32987
32988 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32989 PyObject *resultobj = 0;
32990 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32991 PyObject *arg2 = (PyObject *) 0 ;
32992 PyObject *arg3 = (PyObject *) 0 ;
32993 void *argp1 = 0 ;
32994 int res1 = 0 ;
32995 PyObject * obj0 = 0 ;
32996 PyObject * obj1 = 0 ;
32997 PyObject * obj2 = 0 ;
32998 char * kwnames[] = {
32999 (char *) "self",(char *) "self",(char *) "_class", NULL
33000 };
33001
33002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33004 if (!SWIG_IsOK(res1)) {
33005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33006 }
33007 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33008 arg2 = obj1;
33009 arg3 = obj2;
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 (arg1)->_setCallbackInfo(arg2,arg3);
33013 wxPyEndAllowThreads(__tstate);
33014 if (PyErr_Occurred()) SWIG_fail;
33015 }
33016 resultobj = SWIG_Py_Void();
33017 return resultobj;
33018 fail:
33019 return NULL;
33020 }
33021
33022
33023 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33024 PyObject *resultobj = 0;
33025 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33026 void *argp1 = 0 ;
33027 int res1 = 0 ;
33028 PyObject *swig_obj[1] ;
33029
33030 if (!args) SWIG_fail;
33031 swig_obj[0] = args;
33032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33035 }
33036 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 delete arg1;
33040
33041 wxPyEndAllowThreads(__tstate);
33042 if (PyErr_Occurred()) SWIG_fail;
33043 }
33044 resultobj = SWIG_Py_Void();
33045 return resultobj;
33046 fail:
33047 return NULL;
33048 }
33049
33050
33051 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33052 PyObject *resultobj = 0;
33053 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33054 wxDataObject *result = 0 ;
33055 void *argp1 = 0 ;
33056 int res1 = 0 ;
33057 PyObject *swig_obj[1] ;
33058
33059 if (!args) SWIG_fail;
33060 swig_obj[0] = args;
33061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33062 if (!SWIG_IsOK(res1)) {
33063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33064 }
33065 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33066 {
33067 PyThreadState* __tstate = wxPyBeginAllowThreads();
33068 result = (wxDataObject *)(arg1)->GetDataObject();
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33073 return resultobj;
33074 fail:
33075 return NULL;
33076 }
33077
33078
33079 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33080 PyObject *resultobj = 0;
33081 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33082 wxDataObject *arg2 = (wxDataObject *) 0 ;
33083 void *argp1 = 0 ;
33084 int res1 = 0 ;
33085 int res2 = 0 ;
33086 PyObject * obj0 = 0 ;
33087 PyObject * obj1 = 0 ;
33088 char * kwnames[] = {
33089 (char *) "self",(char *) "dataObject", NULL
33090 };
33091
33092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
33093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33094 if (!SWIG_IsOK(res1)) {
33095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33096 }
33097 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33098 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33099 if (!SWIG_IsOK(res2)) {
33100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
33101 }
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 (arg1)->SetDataObject(arg2);
33105 wxPyEndAllowThreads(__tstate);
33106 if (PyErr_Occurred()) SWIG_fail;
33107 }
33108 resultobj = SWIG_Py_Void();
33109 return resultobj;
33110 fail:
33111 return NULL;
33112 }
33113
33114
33115 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33116 PyObject *resultobj = 0;
33117 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33118 int arg2 ;
33119 int arg3 ;
33120 wxDragResult arg4 ;
33121 wxDragResult result;
33122 void *argp1 = 0 ;
33123 int res1 = 0 ;
33124 int val2 ;
33125 int ecode2 = 0 ;
33126 int val3 ;
33127 int ecode3 = 0 ;
33128 int val4 ;
33129 int ecode4 = 0 ;
33130 PyObject * obj0 = 0 ;
33131 PyObject * obj1 = 0 ;
33132 PyObject * obj2 = 0 ;
33133 PyObject * obj3 = 0 ;
33134 char * kwnames[] = {
33135 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33136 };
33137
33138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33140 if (!SWIG_IsOK(res1)) {
33141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33142 }
33143 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33144 ecode2 = SWIG_AsVal_int(obj1, &val2);
33145 if (!SWIG_IsOK(ecode2)) {
33146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33147 }
33148 arg2 = static_cast< int >(val2);
33149 ecode3 = SWIG_AsVal_int(obj2, &val3);
33150 if (!SWIG_IsOK(ecode3)) {
33151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33152 }
33153 arg3 = static_cast< int >(val3);
33154 ecode4 = SWIG_AsVal_int(obj3, &val4);
33155 if (!SWIG_IsOK(ecode4)) {
33156 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33157 }
33158 arg4 = static_cast< wxDragResult >(val4);
33159 {
33160 PyThreadState* __tstate = wxPyBeginAllowThreads();
33161 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33162 wxPyEndAllowThreads(__tstate);
33163 if (PyErr_Occurred()) SWIG_fail;
33164 }
33165 resultobj = SWIG_From_int(static_cast< int >(result));
33166 return resultobj;
33167 fail:
33168 return NULL;
33169 }
33170
33171
33172 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33173 PyObject *resultobj = 0;
33174 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33175 int arg2 ;
33176 int arg3 ;
33177 wxDragResult arg4 ;
33178 wxDragResult result;
33179 void *argp1 = 0 ;
33180 int res1 = 0 ;
33181 int val2 ;
33182 int ecode2 = 0 ;
33183 int val3 ;
33184 int ecode3 = 0 ;
33185 int val4 ;
33186 int ecode4 = 0 ;
33187 PyObject * obj0 = 0 ;
33188 PyObject * obj1 = 0 ;
33189 PyObject * obj2 = 0 ;
33190 PyObject * obj3 = 0 ;
33191 char * kwnames[] = {
33192 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33193 };
33194
33195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33197 if (!SWIG_IsOK(res1)) {
33198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33199 }
33200 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33201 ecode2 = SWIG_AsVal_int(obj1, &val2);
33202 if (!SWIG_IsOK(ecode2)) {
33203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33204 }
33205 arg2 = static_cast< int >(val2);
33206 ecode3 = SWIG_AsVal_int(obj2, &val3);
33207 if (!SWIG_IsOK(ecode3)) {
33208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33209 }
33210 arg3 = static_cast< int >(val3);
33211 ecode4 = SWIG_AsVal_int(obj3, &val4);
33212 if (!SWIG_IsOK(ecode4)) {
33213 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33214 }
33215 arg4 = static_cast< wxDragResult >(val4);
33216 {
33217 PyThreadState* __tstate = wxPyBeginAllowThreads();
33218 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33219 wxPyEndAllowThreads(__tstate);
33220 if (PyErr_Occurred()) SWIG_fail;
33221 }
33222 resultobj = SWIG_From_int(static_cast< int >(result));
33223 return resultobj;
33224 fail:
33225 return NULL;
33226 }
33227
33228
33229 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33230 PyObject *resultobj = 0;
33231 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33232 void *argp1 = 0 ;
33233 int res1 = 0 ;
33234 PyObject *swig_obj[1] ;
33235
33236 if (!args) SWIG_fail;
33237 swig_obj[0] = args;
33238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33239 if (!SWIG_IsOK(res1)) {
33240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33241 }
33242 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33243 {
33244 PyThreadState* __tstate = wxPyBeginAllowThreads();
33245 (arg1)->OnLeave();
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 resultobj = SWIG_Py_Void();
33250 return resultobj;
33251 fail:
33252 return NULL;
33253 }
33254
33255
33256 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33257 PyObject *resultobj = 0;
33258 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33259 int arg2 ;
33260 int arg3 ;
33261 bool result;
33262 void *argp1 = 0 ;
33263 int res1 = 0 ;
33264 int val2 ;
33265 int ecode2 = 0 ;
33266 int val3 ;
33267 int ecode3 = 0 ;
33268 PyObject * obj0 = 0 ;
33269 PyObject * obj1 = 0 ;
33270 PyObject * obj2 = 0 ;
33271 char * kwnames[] = {
33272 (char *) "self",(char *) "x",(char *) "y", NULL
33273 };
33274
33275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33277 if (!SWIG_IsOK(res1)) {
33278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33279 }
33280 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33281 ecode2 = SWIG_AsVal_int(obj1, &val2);
33282 if (!SWIG_IsOK(ecode2)) {
33283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33284 }
33285 arg2 = static_cast< int >(val2);
33286 ecode3 = SWIG_AsVal_int(obj2, &val3);
33287 if (!SWIG_IsOK(ecode3)) {
33288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33289 }
33290 arg3 = static_cast< int >(val3);
33291 {
33292 PyThreadState* __tstate = wxPyBeginAllowThreads();
33293 result = (bool)(arg1)->OnDrop(arg2,arg3);
33294 wxPyEndAllowThreads(__tstate);
33295 if (PyErr_Occurred()) SWIG_fail;
33296 }
33297 {
33298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33299 }
33300 return resultobj;
33301 fail:
33302 return NULL;
33303 }
33304
33305
33306 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33307 PyObject *resultobj = 0;
33308 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33309 bool result;
33310 void *argp1 = 0 ;
33311 int res1 = 0 ;
33312 PyObject *swig_obj[1] ;
33313
33314 if (!args) SWIG_fail;
33315 swig_obj[0] = args;
33316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33317 if (!SWIG_IsOK(res1)) {
33318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33319 }
33320 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33321 {
33322 PyThreadState* __tstate = wxPyBeginAllowThreads();
33323 result = (bool)(arg1)->GetData();
33324 wxPyEndAllowThreads(__tstate);
33325 if (PyErr_Occurred()) SWIG_fail;
33326 }
33327 {
33328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33329 }
33330 return resultobj;
33331 fail:
33332 return NULL;
33333 }
33334
33335
33336 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33337 PyObject *resultobj = 0;
33338 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33339 wxDragResult arg2 ;
33340 void *argp1 = 0 ;
33341 int res1 = 0 ;
33342 int val2 ;
33343 int ecode2 = 0 ;
33344 PyObject * obj0 = 0 ;
33345 PyObject * obj1 = 0 ;
33346 char * kwnames[] = {
33347 (char *) "self",(char *) "action", NULL
33348 };
33349
33350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33352 if (!SWIG_IsOK(res1)) {
33353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33354 }
33355 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33356 ecode2 = SWIG_AsVal_int(obj1, &val2);
33357 if (!SWIG_IsOK(ecode2)) {
33358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33359 }
33360 arg2 = static_cast< wxDragResult >(val2);
33361 {
33362 PyThreadState* __tstate = wxPyBeginAllowThreads();
33363 (arg1)->SetDefaultAction(arg2);
33364 wxPyEndAllowThreads(__tstate);
33365 if (PyErr_Occurred()) SWIG_fail;
33366 }
33367 resultobj = SWIG_Py_Void();
33368 return resultobj;
33369 fail:
33370 return NULL;
33371 }
33372
33373
33374 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33375 PyObject *resultobj = 0;
33376 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33377 wxDragResult result;
33378 void *argp1 = 0 ;
33379 int res1 = 0 ;
33380 PyObject *swig_obj[1] ;
33381
33382 if (!args) SWIG_fail;
33383 swig_obj[0] = args;
33384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33385 if (!SWIG_IsOK(res1)) {
33386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33387 }
33388 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33389 {
33390 PyThreadState* __tstate = wxPyBeginAllowThreads();
33391 result = (wxDragResult)(arg1)->GetDefaultAction();
33392 wxPyEndAllowThreads(__tstate);
33393 if (PyErr_Occurred()) SWIG_fail;
33394 }
33395 resultobj = SWIG_From_int(static_cast< int >(result));
33396 return resultobj;
33397 fail:
33398 return NULL;
33399 }
33400
33401
33402 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33403 PyObject *obj;
33404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33405 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33406 return SWIG_Py_Void();
33407 }
33408
33409 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33410 return SWIG_Python_InitShadowInstance(args);
33411 }
33412
33413 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33414 PyObject *resultobj = 0;
33415 wxPyTextDropTarget *result = 0 ;
33416
33417 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33418 {
33419 PyThreadState* __tstate = wxPyBeginAllowThreads();
33420 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33421 wxPyEndAllowThreads(__tstate);
33422 if (PyErr_Occurred()) SWIG_fail;
33423 }
33424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33425 return resultobj;
33426 fail:
33427 return NULL;
33428 }
33429
33430
33431 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33432 PyObject *resultobj = 0;
33433 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33434 PyObject *arg2 = (PyObject *) 0 ;
33435 PyObject *arg3 = (PyObject *) 0 ;
33436 void *argp1 = 0 ;
33437 int res1 = 0 ;
33438 PyObject * obj0 = 0 ;
33439 PyObject * obj1 = 0 ;
33440 PyObject * obj2 = 0 ;
33441 char * kwnames[] = {
33442 (char *) "self",(char *) "self",(char *) "_class", NULL
33443 };
33444
33445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33447 if (!SWIG_IsOK(res1)) {
33448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33449 }
33450 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33451 arg2 = obj1;
33452 arg3 = obj2;
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 (arg1)->_setCallbackInfo(arg2,arg3);
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = SWIG_Py_Void();
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33467 PyObject *resultobj = 0;
33468 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33469 int arg2 ;
33470 int arg3 ;
33471 wxString *arg4 = 0 ;
33472 bool result;
33473 void *argp1 = 0 ;
33474 int res1 = 0 ;
33475 int val2 ;
33476 int ecode2 = 0 ;
33477 int val3 ;
33478 int ecode3 = 0 ;
33479 bool temp4 = false ;
33480 PyObject * obj0 = 0 ;
33481 PyObject * obj1 = 0 ;
33482 PyObject * obj2 = 0 ;
33483 PyObject * obj3 = 0 ;
33484 char * kwnames[] = {
33485 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33486 };
33487
33488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33490 if (!SWIG_IsOK(res1)) {
33491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33492 }
33493 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33494 ecode2 = SWIG_AsVal_int(obj1, &val2);
33495 if (!SWIG_IsOK(ecode2)) {
33496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33497 }
33498 arg2 = static_cast< int >(val2);
33499 ecode3 = SWIG_AsVal_int(obj2, &val3);
33500 if (!SWIG_IsOK(ecode3)) {
33501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33502 }
33503 arg3 = static_cast< int >(val3);
33504 {
33505 arg4 = wxString_in_helper(obj3);
33506 if (arg4 == NULL) SWIG_fail;
33507 temp4 = true;
33508 }
33509 {
33510 PyThreadState* __tstate = wxPyBeginAllowThreads();
33511 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33512 wxPyEndAllowThreads(__tstate);
33513 if (PyErr_Occurred()) SWIG_fail;
33514 }
33515 {
33516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33517 }
33518 {
33519 if (temp4)
33520 delete arg4;
33521 }
33522 return resultobj;
33523 fail:
33524 {
33525 if (temp4)
33526 delete arg4;
33527 }
33528 return NULL;
33529 }
33530
33531
33532 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33533 PyObject *resultobj = 0;
33534 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33535 int arg2 ;
33536 int arg3 ;
33537 wxDragResult arg4 ;
33538 wxDragResult result;
33539 void *argp1 = 0 ;
33540 int res1 = 0 ;
33541 int val2 ;
33542 int ecode2 = 0 ;
33543 int val3 ;
33544 int ecode3 = 0 ;
33545 int val4 ;
33546 int ecode4 = 0 ;
33547 PyObject * obj0 = 0 ;
33548 PyObject * obj1 = 0 ;
33549 PyObject * obj2 = 0 ;
33550 PyObject * obj3 = 0 ;
33551 char * kwnames[] = {
33552 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33553 };
33554
33555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33557 if (!SWIG_IsOK(res1)) {
33558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33559 }
33560 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33561 ecode2 = SWIG_AsVal_int(obj1, &val2);
33562 if (!SWIG_IsOK(ecode2)) {
33563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33564 }
33565 arg2 = static_cast< int >(val2);
33566 ecode3 = SWIG_AsVal_int(obj2, &val3);
33567 if (!SWIG_IsOK(ecode3)) {
33568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33569 }
33570 arg3 = static_cast< int >(val3);
33571 ecode4 = SWIG_AsVal_int(obj3, &val4);
33572 if (!SWIG_IsOK(ecode4)) {
33573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33574 }
33575 arg4 = static_cast< wxDragResult >(val4);
33576 {
33577 PyThreadState* __tstate = wxPyBeginAllowThreads();
33578 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33579 wxPyEndAllowThreads(__tstate);
33580 if (PyErr_Occurred()) SWIG_fail;
33581 }
33582 resultobj = SWIG_From_int(static_cast< int >(result));
33583 return resultobj;
33584 fail:
33585 return NULL;
33586 }
33587
33588
33589 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33590 PyObject *resultobj = 0;
33591 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33592 int arg2 ;
33593 int arg3 ;
33594 wxDragResult arg4 ;
33595 wxDragResult result;
33596 void *argp1 = 0 ;
33597 int res1 = 0 ;
33598 int val2 ;
33599 int ecode2 = 0 ;
33600 int val3 ;
33601 int ecode3 = 0 ;
33602 int val4 ;
33603 int ecode4 = 0 ;
33604 PyObject * obj0 = 0 ;
33605 PyObject * obj1 = 0 ;
33606 PyObject * obj2 = 0 ;
33607 PyObject * obj3 = 0 ;
33608 char * kwnames[] = {
33609 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33610 };
33611
33612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33614 if (!SWIG_IsOK(res1)) {
33615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33616 }
33617 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33618 ecode2 = SWIG_AsVal_int(obj1, &val2);
33619 if (!SWIG_IsOK(ecode2)) {
33620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33621 }
33622 arg2 = static_cast< int >(val2);
33623 ecode3 = SWIG_AsVal_int(obj2, &val3);
33624 if (!SWIG_IsOK(ecode3)) {
33625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33626 }
33627 arg3 = static_cast< int >(val3);
33628 ecode4 = SWIG_AsVal_int(obj3, &val4);
33629 if (!SWIG_IsOK(ecode4)) {
33630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33631 }
33632 arg4 = static_cast< wxDragResult >(val4);
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33636 wxPyEndAllowThreads(__tstate);
33637 if (PyErr_Occurred()) SWIG_fail;
33638 }
33639 resultobj = SWIG_From_int(static_cast< int >(result));
33640 return resultobj;
33641 fail:
33642 return NULL;
33643 }
33644
33645
33646 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33647 PyObject *resultobj = 0;
33648 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33649 void *argp1 = 0 ;
33650 int res1 = 0 ;
33651 PyObject *swig_obj[1] ;
33652
33653 if (!args) SWIG_fail;
33654 swig_obj[0] = args;
33655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33656 if (!SWIG_IsOK(res1)) {
33657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33658 }
33659 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33660 {
33661 PyThreadState* __tstate = wxPyBeginAllowThreads();
33662 (arg1)->OnLeave();
33663 wxPyEndAllowThreads(__tstate);
33664 if (PyErr_Occurred()) SWIG_fail;
33665 }
33666 resultobj = SWIG_Py_Void();
33667 return resultobj;
33668 fail:
33669 return NULL;
33670 }
33671
33672
33673 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33674 PyObject *resultobj = 0;
33675 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33676 int arg2 ;
33677 int arg3 ;
33678 bool result;
33679 void *argp1 = 0 ;
33680 int res1 = 0 ;
33681 int val2 ;
33682 int ecode2 = 0 ;
33683 int val3 ;
33684 int ecode3 = 0 ;
33685 PyObject * obj0 = 0 ;
33686 PyObject * obj1 = 0 ;
33687 PyObject * obj2 = 0 ;
33688 char * kwnames[] = {
33689 (char *) "self",(char *) "x",(char *) "y", NULL
33690 };
33691
33692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33694 if (!SWIG_IsOK(res1)) {
33695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33696 }
33697 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33698 ecode2 = SWIG_AsVal_int(obj1, &val2);
33699 if (!SWIG_IsOK(ecode2)) {
33700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33701 }
33702 arg2 = static_cast< int >(val2);
33703 ecode3 = SWIG_AsVal_int(obj2, &val3);
33704 if (!SWIG_IsOK(ecode3)) {
33705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33706 }
33707 arg3 = static_cast< int >(val3);
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = (bool)(arg1)->OnDrop(arg2,arg3);
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 {
33715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33716 }
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj = 0;
33725 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33726 int arg2 ;
33727 int arg3 ;
33728 wxDragResult arg4 ;
33729 wxDragResult result;
33730 void *argp1 = 0 ;
33731 int res1 = 0 ;
33732 int val2 ;
33733 int ecode2 = 0 ;
33734 int val3 ;
33735 int ecode3 = 0 ;
33736 int val4 ;
33737 int ecode4 = 0 ;
33738 PyObject * obj0 = 0 ;
33739 PyObject * obj1 = 0 ;
33740 PyObject * obj2 = 0 ;
33741 PyObject * obj3 = 0 ;
33742 char * kwnames[] = {
33743 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33744 };
33745
33746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33748 if (!SWIG_IsOK(res1)) {
33749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33750 }
33751 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33752 ecode2 = SWIG_AsVal_int(obj1, &val2);
33753 if (!SWIG_IsOK(ecode2)) {
33754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33755 }
33756 arg2 = static_cast< int >(val2);
33757 ecode3 = SWIG_AsVal_int(obj2, &val3);
33758 if (!SWIG_IsOK(ecode3)) {
33759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33760 }
33761 arg3 = static_cast< int >(val3);
33762 ecode4 = SWIG_AsVal_int(obj3, &val4);
33763 if (!SWIG_IsOK(ecode4)) {
33764 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33765 }
33766 arg4 = static_cast< wxDragResult >(val4);
33767 {
33768 PyThreadState* __tstate = wxPyBeginAllowThreads();
33769 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33770 wxPyEndAllowThreads(__tstate);
33771 if (PyErr_Occurred()) SWIG_fail;
33772 }
33773 resultobj = SWIG_From_int(static_cast< int >(result));
33774 return resultobj;
33775 fail:
33776 return NULL;
33777 }
33778
33779
33780 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33781 PyObject *obj;
33782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33783 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33784 return SWIG_Py_Void();
33785 }
33786
33787 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33788 return SWIG_Python_InitShadowInstance(args);
33789 }
33790
33791 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33792 PyObject *resultobj = 0;
33793 wxPyFileDropTarget *result = 0 ;
33794
33795 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33796 {
33797 PyThreadState* __tstate = wxPyBeginAllowThreads();
33798 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33799 wxPyEndAllowThreads(__tstate);
33800 if (PyErr_Occurred()) SWIG_fail;
33801 }
33802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33803 return resultobj;
33804 fail:
33805 return NULL;
33806 }
33807
33808
33809 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33810 PyObject *resultobj = 0;
33811 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33812 PyObject *arg2 = (PyObject *) 0 ;
33813 PyObject *arg3 = (PyObject *) 0 ;
33814 void *argp1 = 0 ;
33815 int res1 = 0 ;
33816 PyObject * obj0 = 0 ;
33817 PyObject * obj1 = 0 ;
33818 PyObject * obj2 = 0 ;
33819 char * kwnames[] = {
33820 (char *) "self",(char *) "self",(char *) "_class", NULL
33821 };
33822
33823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33825 if (!SWIG_IsOK(res1)) {
33826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33827 }
33828 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33829 arg2 = obj1;
33830 arg3 = obj2;
33831 {
33832 PyThreadState* __tstate = wxPyBeginAllowThreads();
33833 (arg1)->_setCallbackInfo(arg2,arg3);
33834 wxPyEndAllowThreads(__tstate);
33835 if (PyErr_Occurred()) SWIG_fail;
33836 }
33837 resultobj = SWIG_Py_Void();
33838 return resultobj;
33839 fail:
33840 return NULL;
33841 }
33842
33843
33844 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33845 PyObject *resultobj = 0;
33846 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33847 int arg2 ;
33848 int arg3 ;
33849 wxArrayString *arg4 = 0 ;
33850 bool result;
33851 void *argp1 = 0 ;
33852 int res1 = 0 ;
33853 int val2 ;
33854 int ecode2 = 0 ;
33855 int val3 ;
33856 int ecode3 = 0 ;
33857 bool temp4 = false ;
33858 PyObject * obj0 = 0 ;
33859 PyObject * obj1 = 0 ;
33860 PyObject * obj2 = 0 ;
33861 PyObject * obj3 = 0 ;
33862 char * kwnames[] = {
33863 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33864 };
33865
33866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33868 if (!SWIG_IsOK(res1)) {
33869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33870 }
33871 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33872 ecode2 = SWIG_AsVal_int(obj1, &val2);
33873 if (!SWIG_IsOK(ecode2)) {
33874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33875 }
33876 arg2 = static_cast< int >(val2);
33877 ecode3 = SWIG_AsVal_int(obj2, &val3);
33878 if (!SWIG_IsOK(ecode3)) {
33879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33880 }
33881 arg3 = static_cast< int >(val3);
33882 {
33883 if (! PySequence_Check(obj3)) {
33884 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33885 SWIG_fail;
33886 }
33887 arg4 = new wxArrayString;
33888 temp4 = true;
33889 int i, len=PySequence_Length(obj3);
33890 for (i=0; i<len; i++) {
33891 PyObject* item = PySequence_GetItem(obj3, i);
33892 wxString* s = wxString_in_helper(item);
33893 if (PyErr_Occurred()) SWIG_fail;
33894 arg4->Add(*s);
33895 delete s;
33896 Py_DECREF(item);
33897 }
33898 }
33899 {
33900 PyThreadState* __tstate = wxPyBeginAllowThreads();
33901 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 {
33906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33907 }
33908 {
33909 if (temp4) delete arg4;
33910 }
33911 return resultobj;
33912 fail:
33913 {
33914 if (temp4) delete arg4;
33915 }
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj = 0;
33922 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33923 int arg2 ;
33924 int arg3 ;
33925 wxDragResult arg4 ;
33926 wxDragResult result;
33927 void *argp1 = 0 ;
33928 int res1 = 0 ;
33929 int val2 ;
33930 int ecode2 = 0 ;
33931 int val3 ;
33932 int ecode3 = 0 ;
33933 int val4 ;
33934 int ecode4 = 0 ;
33935 PyObject * obj0 = 0 ;
33936 PyObject * obj1 = 0 ;
33937 PyObject * obj2 = 0 ;
33938 PyObject * obj3 = 0 ;
33939 char * kwnames[] = {
33940 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33941 };
33942
33943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33945 if (!SWIG_IsOK(res1)) {
33946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33947 }
33948 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33949 ecode2 = SWIG_AsVal_int(obj1, &val2);
33950 if (!SWIG_IsOK(ecode2)) {
33951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33952 }
33953 arg2 = static_cast< int >(val2);
33954 ecode3 = SWIG_AsVal_int(obj2, &val3);
33955 if (!SWIG_IsOK(ecode3)) {
33956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33957 }
33958 arg3 = static_cast< int >(val3);
33959 ecode4 = SWIG_AsVal_int(obj3, &val4);
33960 if (!SWIG_IsOK(ecode4)) {
33961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33962 }
33963 arg4 = static_cast< wxDragResult >(val4);
33964 {
33965 PyThreadState* __tstate = wxPyBeginAllowThreads();
33966 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33967 wxPyEndAllowThreads(__tstate);
33968 if (PyErr_Occurred()) SWIG_fail;
33969 }
33970 resultobj = SWIG_From_int(static_cast< int >(result));
33971 return resultobj;
33972 fail:
33973 return NULL;
33974 }
33975
33976
33977 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33978 PyObject *resultobj = 0;
33979 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33980 int arg2 ;
33981 int arg3 ;
33982 wxDragResult arg4 ;
33983 wxDragResult result;
33984 void *argp1 = 0 ;
33985 int res1 = 0 ;
33986 int val2 ;
33987 int ecode2 = 0 ;
33988 int val3 ;
33989 int ecode3 = 0 ;
33990 int val4 ;
33991 int ecode4 = 0 ;
33992 PyObject * obj0 = 0 ;
33993 PyObject * obj1 = 0 ;
33994 PyObject * obj2 = 0 ;
33995 PyObject * obj3 = 0 ;
33996 char * kwnames[] = {
33997 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33998 };
33999
34000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34002 if (!SWIG_IsOK(res1)) {
34003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34004 }
34005 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34006 ecode2 = SWIG_AsVal_int(obj1, &val2);
34007 if (!SWIG_IsOK(ecode2)) {
34008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34009 }
34010 arg2 = static_cast< int >(val2);
34011 ecode3 = SWIG_AsVal_int(obj2, &val3);
34012 if (!SWIG_IsOK(ecode3)) {
34013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34014 }
34015 arg3 = static_cast< int >(val3);
34016 ecode4 = SWIG_AsVal_int(obj3, &val4);
34017 if (!SWIG_IsOK(ecode4)) {
34018 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34019 }
34020 arg4 = static_cast< wxDragResult >(val4);
34021 {
34022 PyThreadState* __tstate = wxPyBeginAllowThreads();
34023 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34024 wxPyEndAllowThreads(__tstate);
34025 if (PyErr_Occurred()) SWIG_fail;
34026 }
34027 resultobj = SWIG_From_int(static_cast< int >(result));
34028 return resultobj;
34029 fail:
34030 return NULL;
34031 }
34032
34033
34034 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34035 PyObject *resultobj = 0;
34036 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 PyObject *swig_obj[1] ;
34040
34041 if (!args) SWIG_fail;
34042 swig_obj[0] = args;
34043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34044 if (!SWIG_IsOK(res1)) {
34045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34046 }
34047 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34048 {
34049 PyThreadState* __tstate = wxPyBeginAllowThreads();
34050 (arg1)->OnLeave();
34051 wxPyEndAllowThreads(__tstate);
34052 if (PyErr_Occurred()) SWIG_fail;
34053 }
34054 resultobj = SWIG_Py_Void();
34055 return resultobj;
34056 fail:
34057 return NULL;
34058 }
34059
34060
34061 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34062 PyObject *resultobj = 0;
34063 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34064 int arg2 ;
34065 int arg3 ;
34066 bool result;
34067 void *argp1 = 0 ;
34068 int res1 = 0 ;
34069 int val2 ;
34070 int ecode2 = 0 ;
34071 int val3 ;
34072 int ecode3 = 0 ;
34073 PyObject * obj0 = 0 ;
34074 PyObject * obj1 = 0 ;
34075 PyObject * obj2 = 0 ;
34076 char * kwnames[] = {
34077 (char *) "self",(char *) "x",(char *) "y", NULL
34078 };
34079
34080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34082 if (!SWIG_IsOK(res1)) {
34083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34084 }
34085 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34086 ecode2 = SWIG_AsVal_int(obj1, &val2);
34087 if (!SWIG_IsOK(ecode2)) {
34088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34089 }
34090 arg2 = static_cast< int >(val2);
34091 ecode3 = SWIG_AsVal_int(obj2, &val3);
34092 if (!SWIG_IsOK(ecode3)) {
34093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34094 }
34095 arg3 = static_cast< int >(val3);
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 result = (bool)(arg1)->OnDrop(arg2,arg3);
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 {
34103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34104 }
34105 return resultobj;
34106 fail:
34107 return NULL;
34108 }
34109
34110
34111 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34112 PyObject *resultobj = 0;
34113 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34114 int arg2 ;
34115 int arg3 ;
34116 wxDragResult arg4 ;
34117 wxDragResult result;
34118 void *argp1 = 0 ;
34119 int res1 = 0 ;
34120 int val2 ;
34121 int ecode2 = 0 ;
34122 int val3 ;
34123 int ecode3 = 0 ;
34124 int val4 ;
34125 int ecode4 = 0 ;
34126 PyObject * obj0 = 0 ;
34127 PyObject * obj1 = 0 ;
34128 PyObject * obj2 = 0 ;
34129 PyObject * obj3 = 0 ;
34130 char * kwnames[] = {
34131 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34132 };
34133
34134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34136 if (!SWIG_IsOK(res1)) {
34137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34138 }
34139 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34140 ecode2 = SWIG_AsVal_int(obj1, &val2);
34141 if (!SWIG_IsOK(ecode2)) {
34142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34143 }
34144 arg2 = static_cast< int >(val2);
34145 ecode3 = SWIG_AsVal_int(obj2, &val3);
34146 if (!SWIG_IsOK(ecode3)) {
34147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34148 }
34149 arg3 = static_cast< int >(val3);
34150 ecode4 = SWIG_AsVal_int(obj3, &val4);
34151 if (!SWIG_IsOK(ecode4)) {
34152 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34153 }
34154 arg4 = static_cast< wxDragResult >(val4);
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 resultobj = SWIG_From_int(static_cast< int >(result));
34162 return resultobj;
34163 fail:
34164 return NULL;
34165 }
34166
34167
34168 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34169 PyObject *obj;
34170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34171 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
34172 return SWIG_Py_Void();
34173 }
34174
34175 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34176 return SWIG_Python_InitShadowInstance(args);
34177 }
34178
34179 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34180 PyObject *resultobj = 0;
34181 wxClipboard *result = 0 ;
34182
34183 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 result = (wxClipboard *)new wxClipboard();
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34198 PyObject *resultobj = 0;
34199 wxClipboard *arg1 = (wxClipboard *) 0 ;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 PyObject *swig_obj[1] ;
34203
34204 if (!args) SWIG_fail;
34205 swig_obj[0] = args;
34206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34209 }
34210 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34211 {
34212 PyThreadState* __tstate = wxPyBeginAllowThreads();
34213 delete arg1;
34214
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 resultobj = SWIG_Py_Void();
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34226 PyObject *resultobj = 0;
34227 wxClipboard *arg1 = (wxClipboard *) 0 ;
34228 bool result;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 PyObject *swig_obj[1] ;
34232
34233 if (!args) SWIG_fail;
34234 swig_obj[0] = args;
34235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34238 }
34239 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 result = (bool)(arg1)->Open();
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 {
34247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34248 }
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34256 PyObject *resultobj = 0;
34257 wxClipboard *arg1 = (wxClipboard *) 0 ;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 PyObject *swig_obj[1] ;
34261
34262 if (!args) SWIG_fail;
34263 swig_obj[0] = args;
34264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34265 if (!SWIG_IsOK(res1)) {
34266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34267 }
34268 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 (arg1)->Close();
34272 wxPyEndAllowThreads(__tstate);
34273 if (PyErr_Occurred()) SWIG_fail;
34274 }
34275 resultobj = SWIG_Py_Void();
34276 return resultobj;
34277 fail:
34278 return NULL;
34279 }
34280
34281
34282 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34283 PyObject *resultobj = 0;
34284 wxClipboard *arg1 = (wxClipboard *) 0 ;
34285 bool result;
34286 void *argp1 = 0 ;
34287 int res1 = 0 ;
34288 PyObject *swig_obj[1] ;
34289
34290 if (!args) SWIG_fail;
34291 swig_obj[0] = args;
34292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34293 if (!SWIG_IsOK(res1)) {
34294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34295 }
34296 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34297 {
34298 PyThreadState* __tstate = wxPyBeginAllowThreads();
34299 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34300 wxPyEndAllowThreads(__tstate);
34301 if (PyErr_Occurred()) SWIG_fail;
34302 }
34303 {
34304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34305 }
34306 return resultobj;
34307 fail:
34308 return NULL;
34309 }
34310
34311
34312 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34313 PyObject *resultobj = 0;
34314 wxClipboard *arg1 = (wxClipboard *) 0 ;
34315 wxDataObject *arg2 = (wxDataObject *) 0 ;
34316 bool result;
34317 void *argp1 = 0 ;
34318 int res1 = 0 ;
34319 int res2 = 0 ;
34320 PyObject * obj0 = 0 ;
34321 PyObject * obj1 = 0 ;
34322 char * kwnames[] = {
34323 (char *) "self",(char *) "data", NULL
34324 };
34325
34326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34328 if (!SWIG_IsOK(res1)) {
34329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34330 }
34331 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34332 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34333 if (!SWIG_IsOK(res2)) {
34334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34335 }
34336 {
34337 PyThreadState* __tstate = wxPyBeginAllowThreads();
34338 result = (bool)(arg1)->AddData(arg2);
34339 wxPyEndAllowThreads(__tstate);
34340 if (PyErr_Occurred()) SWIG_fail;
34341 }
34342 {
34343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34344 }
34345 return resultobj;
34346 fail:
34347 return NULL;
34348 }
34349
34350
34351 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34352 PyObject *resultobj = 0;
34353 wxClipboard *arg1 = (wxClipboard *) 0 ;
34354 wxDataObject *arg2 = (wxDataObject *) 0 ;
34355 bool result;
34356 void *argp1 = 0 ;
34357 int res1 = 0 ;
34358 int res2 = 0 ;
34359 PyObject * obj0 = 0 ;
34360 PyObject * obj1 = 0 ;
34361 char * kwnames[] = {
34362 (char *) "self",(char *) "data", NULL
34363 };
34364
34365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34367 if (!SWIG_IsOK(res1)) {
34368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34369 }
34370 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34371 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34372 if (!SWIG_IsOK(res2)) {
34373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34374 }
34375 {
34376 PyThreadState* __tstate = wxPyBeginAllowThreads();
34377 result = (bool)(arg1)->SetData(arg2);
34378 wxPyEndAllowThreads(__tstate);
34379 if (PyErr_Occurred()) SWIG_fail;
34380 }
34381 {
34382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34383 }
34384 return resultobj;
34385 fail:
34386 return NULL;
34387 }
34388
34389
34390 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34391 PyObject *resultobj = 0;
34392 wxClipboard *arg1 = (wxClipboard *) 0 ;
34393 wxDataFormat *arg2 = 0 ;
34394 bool result;
34395 void *argp1 = 0 ;
34396 int res1 = 0 ;
34397 void *argp2 = 0 ;
34398 int res2 = 0 ;
34399 PyObject * obj0 = 0 ;
34400 PyObject * obj1 = 0 ;
34401 char * kwnames[] = {
34402 (char *) "self",(char *) "format", NULL
34403 };
34404
34405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34407 if (!SWIG_IsOK(res1)) {
34408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34409 }
34410 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34411 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34412 if (!SWIG_IsOK(res2)) {
34413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34414 }
34415 if (!argp2) {
34416 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34417 }
34418 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34419 {
34420 PyThreadState* __tstate = wxPyBeginAllowThreads();
34421 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34422 wxPyEndAllowThreads(__tstate);
34423 if (PyErr_Occurred()) SWIG_fail;
34424 }
34425 {
34426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34427 }
34428 return resultobj;
34429 fail:
34430 return NULL;
34431 }
34432
34433
34434 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34435 PyObject *resultobj = 0;
34436 wxClipboard *arg1 = (wxClipboard *) 0 ;
34437 wxDataObject *arg2 = 0 ;
34438 bool result;
34439 void *argp1 = 0 ;
34440 int res1 = 0 ;
34441 void *argp2 = 0 ;
34442 int res2 = 0 ;
34443 PyObject * obj0 = 0 ;
34444 PyObject * obj1 = 0 ;
34445 char * kwnames[] = {
34446 (char *) "self",(char *) "data", NULL
34447 };
34448
34449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34451 if (!SWIG_IsOK(res1)) {
34452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34453 }
34454 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34455 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34456 if (!SWIG_IsOK(res2)) {
34457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34458 }
34459 if (!argp2) {
34460 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34461 }
34462 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34463 {
34464 PyThreadState* __tstate = wxPyBeginAllowThreads();
34465 result = (bool)(arg1)->GetData(*arg2);
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 {
34470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34471 }
34472 return resultobj;
34473 fail:
34474 return NULL;
34475 }
34476
34477
34478 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34479 PyObject *resultobj = 0;
34480 wxClipboard *arg1 = (wxClipboard *) 0 ;
34481 void *argp1 = 0 ;
34482 int res1 = 0 ;
34483 PyObject *swig_obj[1] ;
34484
34485 if (!args) SWIG_fail;
34486 swig_obj[0] = args;
34487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34488 if (!SWIG_IsOK(res1)) {
34489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34490 }
34491 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 (arg1)->Clear();
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 resultobj = SWIG_Py_Void();
34499 return resultobj;
34500 fail:
34501 return NULL;
34502 }
34503
34504
34505 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34506 PyObject *resultobj = 0;
34507 wxClipboard *arg1 = (wxClipboard *) 0 ;
34508 bool result;
34509 void *argp1 = 0 ;
34510 int res1 = 0 ;
34511 PyObject *swig_obj[1] ;
34512
34513 if (!args) SWIG_fail;
34514 swig_obj[0] = args;
34515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34516 if (!SWIG_IsOK(res1)) {
34517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34518 }
34519 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34520 {
34521 PyThreadState* __tstate = wxPyBeginAllowThreads();
34522 result = (bool)(arg1)->Flush();
34523 wxPyEndAllowThreads(__tstate);
34524 if (PyErr_Occurred()) SWIG_fail;
34525 }
34526 {
34527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34528 }
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34536 PyObject *resultobj = 0;
34537 wxClipboard *arg1 = (wxClipboard *) 0 ;
34538 bool arg2 = (bool) true ;
34539 void *argp1 = 0 ;
34540 int res1 = 0 ;
34541 bool val2 ;
34542 int ecode2 = 0 ;
34543 PyObject * obj0 = 0 ;
34544 PyObject * obj1 = 0 ;
34545 char * kwnames[] = {
34546 (char *) "self",(char *) "primary", NULL
34547 };
34548
34549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34551 if (!SWIG_IsOK(res1)) {
34552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34553 }
34554 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34555 if (obj1) {
34556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34557 if (!SWIG_IsOK(ecode2)) {
34558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34559 }
34560 arg2 = static_cast< bool >(val2);
34561 }
34562 {
34563 PyThreadState* __tstate = wxPyBeginAllowThreads();
34564 (arg1)->UsePrimarySelection(arg2);
34565 wxPyEndAllowThreads(__tstate);
34566 if (PyErr_Occurred()) SWIG_fail;
34567 }
34568 resultobj = SWIG_Py_Void();
34569 return resultobj;
34570 fail:
34571 return NULL;
34572 }
34573
34574
34575 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34576 PyObject *resultobj = 0;
34577 wxClipboard *result = 0 ;
34578
34579 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34580 {
34581 PyThreadState* __tstate = wxPyBeginAllowThreads();
34582 result = (wxClipboard *)wxClipboard::Get();
34583 wxPyEndAllowThreads(__tstate);
34584 if (PyErr_Occurred()) SWIG_fail;
34585 }
34586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34587 return resultobj;
34588 fail:
34589 return NULL;
34590 }
34591
34592
34593 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34594 PyObject *obj;
34595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34596 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34597 return SWIG_Py_Void();
34598 }
34599
34600 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34601 return SWIG_Python_InitShadowInstance(args);
34602 }
34603
34604 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34605 PyObject *resultobj = 0;
34606 wxClipboard *arg1 = (wxClipboard *) NULL ;
34607 wxClipboardLocker *result = 0 ;
34608 void *argp1 = 0 ;
34609 int res1 = 0 ;
34610 PyObject * obj0 = 0 ;
34611 char * kwnames[] = {
34612 (char *) "clipboard", NULL
34613 };
34614
34615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34616 if (obj0) {
34617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34618 if (!SWIG_IsOK(res1)) {
34619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34620 }
34621 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34622 }
34623 {
34624 PyThreadState* __tstate = wxPyBeginAllowThreads();
34625 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34626 wxPyEndAllowThreads(__tstate);
34627 if (PyErr_Occurred()) SWIG_fail;
34628 }
34629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34630 return resultobj;
34631 fail:
34632 return NULL;
34633 }
34634
34635
34636 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34637 PyObject *resultobj = 0;
34638 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34639 void *argp1 = 0 ;
34640 int res1 = 0 ;
34641 PyObject *swig_obj[1] ;
34642
34643 if (!args) SWIG_fail;
34644 swig_obj[0] = args;
34645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34646 if (!SWIG_IsOK(res1)) {
34647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34648 }
34649 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 delete arg1;
34653
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 resultobj = SWIG_Py_Void();
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34665 PyObject *resultobj = 0;
34666 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34667 bool result;
34668 void *argp1 = 0 ;
34669 int res1 = 0 ;
34670 PyObject *swig_obj[1] ;
34671
34672 if (!args) SWIG_fail;
34673 swig_obj[0] = args;
34674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34675 if (!SWIG_IsOK(res1)) {
34676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34677 }
34678 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34679 {
34680 PyThreadState* __tstate = wxPyBeginAllowThreads();
34681 result = (bool)wxClipboardLocker___nonzero__(arg1);
34682 wxPyEndAllowThreads(__tstate);
34683 if (PyErr_Occurred()) SWIG_fail;
34684 }
34685 {
34686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34687 }
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34695 PyObject *obj;
34696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34697 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34698 return SWIG_Py_Void();
34699 }
34700
34701 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34702 return SWIG_Python_InitShadowInstance(args);
34703 }
34704
34705 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34706 PyObject *resultobj = 0;
34707 int arg1 = (int) 0 ;
34708 int arg2 = (int) 0 ;
34709 int arg3 = (int) 0 ;
34710 int arg4 = (int) 0 ;
34711 wxVideoMode *result = 0 ;
34712 int val1 ;
34713 int ecode1 = 0 ;
34714 int val2 ;
34715 int ecode2 = 0 ;
34716 int val3 ;
34717 int ecode3 = 0 ;
34718 int val4 ;
34719 int ecode4 = 0 ;
34720 PyObject * obj0 = 0 ;
34721 PyObject * obj1 = 0 ;
34722 PyObject * obj2 = 0 ;
34723 PyObject * obj3 = 0 ;
34724 char * kwnames[] = {
34725 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34726 };
34727
34728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34729 if (obj0) {
34730 ecode1 = SWIG_AsVal_int(obj0, &val1);
34731 if (!SWIG_IsOK(ecode1)) {
34732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34733 }
34734 arg1 = static_cast< int >(val1);
34735 }
34736 if (obj1) {
34737 ecode2 = SWIG_AsVal_int(obj1, &val2);
34738 if (!SWIG_IsOK(ecode2)) {
34739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34740 }
34741 arg2 = static_cast< int >(val2);
34742 }
34743 if (obj2) {
34744 ecode3 = SWIG_AsVal_int(obj2, &val3);
34745 if (!SWIG_IsOK(ecode3)) {
34746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34747 }
34748 arg3 = static_cast< int >(val3);
34749 }
34750 if (obj3) {
34751 ecode4 = SWIG_AsVal_int(obj3, &val4);
34752 if (!SWIG_IsOK(ecode4)) {
34753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34754 }
34755 arg4 = static_cast< int >(val4);
34756 }
34757 {
34758 PyThreadState* __tstate = wxPyBeginAllowThreads();
34759 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34760 wxPyEndAllowThreads(__tstate);
34761 if (PyErr_Occurred()) SWIG_fail;
34762 }
34763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34764 return resultobj;
34765 fail:
34766 return NULL;
34767 }
34768
34769
34770 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34771 PyObject *resultobj = 0;
34772 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34773 void *argp1 = 0 ;
34774 int res1 = 0 ;
34775 PyObject *swig_obj[1] ;
34776
34777 if (!args) SWIG_fail;
34778 swig_obj[0] = args;
34779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34780 if (!SWIG_IsOK(res1)) {
34781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34782 }
34783 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34784 {
34785 PyThreadState* __tstate = wxPyBeginAllowThreads();
34786 delete arg1;
34787
34788 wxPyEndAllowThreads(__tstate);
34789 if (PyErr_Occurred()) SWIG_fail;
34790 }
34791 resultobj = SWIG_Py_Void();
34792 return resultobj;
34793 fail:
34794 return NULL;
34795 }
34796
34797
34798 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34799 PyObject *resultobj = 0;
34800 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34801 wxVideoMode *arg2 = 0 ;
34802 bool result;
34803 void *argp1 = 0 ;
34804 int res1 = 0 ;
34805 void *argp2 = 0 ;
34806 int res2 = 0 ;
34807 PyObject * obj0 = 0 ;
34808 PyObject * obj1 = 0 ;
34809 char * kwnames[] = {
34810 (char *) "self",(char *) "other", NULL
34811 };
34812
34813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34815 if (!SWIG_IsOK(res1)) {
34816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34817 }
34818 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34820 if (!SWIG_IsOK(res2)) {
34821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34822 }
34823 if (!argp2) {
34824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34825 }
34826 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34827 {
34828 PyThreadState* __tstate = wxPyBeginAllowThreads();
34829 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 {
34834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34835 }
34836 return resultobj;
34837 fail:
34838 return NULL;
34839 }
34840
34841
34842 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34843 PyObject *resultobj = 0;
34844 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34845 int result;
34846 void *argp1 = 0 ;
34847 int res1 = 0 ;
34848 PyObject *swig_obj[1] ;
34849
34850 if (!args) SWIG_fail;
34851 swig_obj[0] = args;
34852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34853 if (!SWIG_IsOK(res1)) {
34854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34855 }
34856 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34857 {
34858 PyThreadState* __tstate = wxPyBeginAllowThreads();
34859 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34860 wxPyEndAllowThreads(__tstate);
34861 if (PyErr_Occurred()) SWIG_fail;
34862 }
34863 resultobj = SWIG_From_int(static_cast< int >(result));
34864 return resultobj;
34865 fail:
34866 return NULL;
34867 }
34868
34869
34870 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34871 PyObject *resultobj = 0;
34872 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34873 int result;
34874 void *argp1 = 0 ;
34875 int res1 = 0 ;
34876 PyObject *swig_obj[1] ;
34877
34878 if (!args) SWIG_fail;
34879 swig_obj[0] = args;
34880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34881 if (!SWIG_IsOK(res1)) {
34882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34883 }
34884 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34885 {
34886 PyThreadState* __tstate = wxPyBeginAllowThreads();
34887 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34888 wxPyEndAllowThreads(__tstate);
34889 if (PyErr_Occurred()) SWIG_fail;
34890 }
34891 resultobj = SWIG_From_int(static_cast< int >(result));
34892 return resultobj;
34893 fail:
34894 return NULL;
34895 }
34896
34897
34898 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34899 PyObject *resultobj = 0;
34900 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34901 int result;
34902 void *argp1 = 0 ;
34903 int res1 = 0 ;
34904 PyObject *swig_obj[1] ;
34905
34906 if (!args) SWIG_fail;
34907 swig_obj[0] = args;
34908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34909 if (!SWIG_IsOK(res1)) {
34910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34911 }
34912 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34913 {
34914 PyThreadState* __tstate = wxPyBeginAllowThreads();
34915 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34916 wxPyEndAllowThreads(__tstate);
34917 if (PyErr_Occurred()) SWIG_fail;
34918 }
34919 resultobj = SWIG_From_int(static_cast< int >(result));
34920 return resultobj;
34921 fail:
34922 return NULL;
34923 }
34924
34925
34926 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34927 PyObject *resultobj = 0;
34928 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34929 bool result;
34930 void *argp1 = 0 ;
34931 int res1 = 0 ;
34932 PyObject *swig_obj[1] ;
34933
34934 if (!args) SWIG_fail;
34935 swig_obj[0] = args;
34936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34937 if (!SWIG_IsOK(res1)) {
34938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34939 }
34940 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34941 {
34942 PyThreadState* __tstate = wxPyBeginAllowThreads();
34943 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34944 wxPyEndAllowThreads(__tstate);
34945 if (PyErr_Occurred()) SWIG_fail;
34946 }
34947 {
34948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34949 }
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34957 PyObject *resultobj = 0;
34958 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34959 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34960 bool result;
34961 void *argp1 = 0 ;
34962 int res1 = 0 ;
34963 void *argp2 = 0 ;
34964 int res2 = 0 ;
34965 PyObject * obj0 = 0 ;
34966 PyObject * obj1 = 0 ;
34967 char * kwnames[] = {
34968 (char *) "self",(char *) "other", NULL
34969 };
34970
34971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34975 }
34976 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34978 if (!SWIG_IsOK(res2)) {
34979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34980 }
34981 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34982 {
34983 PyThreadState* __tstate = wxPyBeginAllowThreads();
34984 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34985 wxPyEndAllowThreads(__tstate);
34986 if (PyErr_Occurred()) SWIG_fail;
34987 }
34988 {
34989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34990 }
34991 return resultobj;
34992 fail:
34993 return NULL;
34994 }
34995
34996
34997 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34998 PyObject *resultobj = 0;
34999 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35000 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35001 bool result;
35002 void *argp1 = 0 ;
35003 int res1 = 0 ;
35004 void *argp2 = 0 ;
35005 int res2 = 0 ;
35006 PyObject * obj0 = 0 ;
35007 PyObject * obj1 = 0 ;
35008 char * kwnames[] = {
35009 (char *) "self",(char *) "other", NULL
35010 };
35011
35012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
35013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35014 if (!SWIG_IsOK(res1)) {
35015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35016 }
35017 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35019 if (!SWIG_IsOK(res2)) {
35020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35021 }
35022 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35023 {
35024 PyThreadState* __tstate = wxPyBeginAllowThreads();
35025 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
35026 wxPyEndAllowThreads(__tstate);
35027 if (PyErr_Occurred()) SWIG_fail;
35028 }
35029 {
35030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35031 }
35032 return resultobj;
35033 fail:
35034 return NULL;
35035 }
35036
35037
35038 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35039 PyObject *resultobj = 0;
35040 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35041 int arg2 ;
35042 void *argp1 = 0 ;
35043 int res1 = 0 ;
35044 int val2 ;
35045 int ecode2 = 0 ;
35046 PyObject *swig_obj[2] ;
35047
35048 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
35049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35050 if (!SWIG_IsOK(res1)) {
35051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35052 }
35053 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35054 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35055 if (!SWIG_IsOK(ecode2)) {
35056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35057 }
35058 arg2 = static_cast< int >(val2);
35059 if (arg1) (arg1)->w = arg2;
35060
35061 resultobj = SWIG_Py_Void();
35062 return resultobj;
35063 fail:
35064 return NULL;
35065 }
35066
35067
35068 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35069 PyObject *resultobj = 0;
35070 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35071 int result;
35072 void *argp1 = 0 ;
35073 int res1 = 0 ;
35074 PyObject *swig_obj[1] ;
35075
35076 if (!args) SWIG_fail;
35077 swig_obj[0] = args;
35078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35079 if (!SWIG_IsOK(res1)) {
35080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35081 }
35082 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35083 result = (int) ((arg1)->w);
35084 resultobj = SWIG_From_int(static_cast< int >(result));
35085 return resultobj;
35086 fail:
35087 return NULL;
35088 }
35089
35090
35091 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35092 PyObject *resultobj = 0;
35093 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35094 int arg2 ;
35095 void *argp1 = 0 ;
35096 int res1 = 0 ;
35097 int val2 ;
35098 int ecode2 = 0 ;
35099 PyObject *swig_obj[2] ;
35100
35101 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
35102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35103 if (!SWIG_IsOK(res1)) {
35104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35105 }
35106 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35107 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35108 if (!SWIG_IsOK(ecode2)) {
35109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
35110 }
35111 arg2 = static_cast< int >(val2);
35112 if (arg1) (arg1)->h = arg2;
35113
35114 resultobj = SWIG_Py_Void();
35115 return resultobj;
35116 fail:
35117 return NULL;
35118 }
35119
35120
35121 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35122 PyObject *resultobj = 0;
35123 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35124 int result;
35125 void *argp1 = 0 ;
35126 int res1 = 0 ;
35127 PyObject *swig_obj[1] ;
35128
35129 if (!args) SWIG_fail;
35130 swig_obj[0] = args;
35131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35132 if (!SWIG_IsOK(res1)) {
35133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35134 }
35135 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35136 result = (int) ((arg1)->h);
35137 resultobj = SWIG_From_int(static_cast< int >(result));
35138 return resultobj;
35139 fail:
35140 return NULL;
35141 }
35142
35143
35144 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35145 PyObject *resultobj = 0;
35146 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35147 int arg2 ;
35148 void *argp1 = 0 ;
35149 int res1 = 0 ;
35150 int val2 ;
35151 int ecode2 = 0 ;
35152 PyObject *swig_obj[2] ;
35153
35154 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
35155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35156 if (!SWIG_IsOK(res1)) {
35157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35158 }
35159 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35160 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35161 if (!SWIG_IsOK(ecode2)) {
35162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
35163 }
35164 arg2 = static_cast< int >(val2);
35165 if (arg1) (arg1)->bpp = arg2;
35166
35167 resultobj = SWIG_Py_Void();
35168 return resultobj;
35169 fail:
35170 return NULL;
35171 }
35172
35173
35174 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35175 PyObject *resultobj = 0;
35176 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35177 int result;
35178 void *argp1 = 0 ;
35179 int res1 = 0 ;
35180 PyObject *swig_obj[1] ;
35181
35182 if (!args) SWIG_fail;
35183 swig_obj[0] = args;
35184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35185 if (!SWIG_IsOK(res1)) {
35186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35187 }
35188 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35189 result = (int) ((arg1)->bpp);
35190 resultobj = SWIG_From_int(static_cast< int >(result));
35191 return resultobj;
35192 fail:
35193 return NULL;
35194 }
35195
35196
35197 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35198 PyObject *resultobj = 0;
35199 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35200 int arg2 ;
35201 void *argp1 = 0 ;
35202 int res1 = 0 ;
35203 int val2 ;
35204 int ecode2 = 0 ;
35205 PyObject *swig_obj[2] ;
35206
35207 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35209 if (!SWIG_IsOK(res1)) {
35210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35211 }
35212 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35213 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35214 if (!SWIG_IsOK(ecode2)) {
35215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35216 }
35217 arg2 = static_cast< int >(val2);
35218 if (arg1) (arg1)->refresh = arg2;
35219
35220 resultobj = SWIG_Py_Void();
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35228 PyObject *resultobj = 0;
35229 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35230 int result;
35231 void *argp1 = 0 ;
35232 int res1 = 0 ;
35233 PyObject *swig_obj[1] ;
35234
35235 if (!args) SWIG_fail;
35236 swig_obj[0] = args;
35237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35238 if (!SWIG_IsOK(res1)) {
35239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35240 }
35241 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35242 result = (int) ((arg1)->refresh);
35243 resultobj = SWIG_From_int(static_cast< int >(result));
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35251 PyObject *obj;
35252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35253 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35254 return SWIG_Py_Void();
35255 }
35256
35257 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35258 return SWIG_Python_InitShadowInstance(args);
35259 }
35260
35261 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35262 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35263 return 1;
35264 }
35265
35266
35267 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35268 PyObject *pyobj = 0;
35269
35270 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35271 return pyobj;
35272 }
35273
35274
35275 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35276 PyObject *resultobj = 0;
35277 size_t arg1 = (size_t) 0 ;
35278 wxDisplay *result = 0 ;
35279 size_t val1 ;
35280 int ecode1 = 0 ;
35281 PyObject * obj0 = 0 ;
35282 char * kwnames[] = {
35283 (char *) "index", NULL
35284 };
35285
35286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35287 if (obj0) {
35288 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35289 if (!SWIG_IsOK(ecode1)) {
35290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35291 }
35292 arg1 = static_cast< size_t >(val1);
35293 }
35294 {
35295 PyThreadState* __tstate = wxPyBeginAllowThreads();
35296 result = (wxDisplay *)new wxDisplay(arg1);
35297 wxPyEndAllowThreads(__tstate);
35298 if (PyErr_Occurred()) SWIG_fail;
35299 }
35300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35301 return resultobj;
35302 fail:
35303 return NULL;
35304 }
35305
35306
35307 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35308 PyObject *resultobj = 0;
35309 wxDisplay *arg1 = (wxDisplay *) 0 ;
35310 void *argp1 = 0 ;
35311 int res1 = 0 ;
35312 PyObject *swig_obj[1] ;
35313
35314 if (!args) SWIG_fail;
35315 swig_obj[0] = args;
35316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35317 if (!SWIG_IsOK(res1)) {
35318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35319 }
35320 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 delete arg1;
35324
35325 wxPyEndAllowThreads(__tstate);
35326 if (PyErr_Occurred()) SWIG_fail;
35327 }
35328 resultobj = SWIG_Py_Void();
35329 return resultobj;
35330 fail:
35331 return NULL;
35332 }
35333
35334
35335 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35336 PyObject *resultobj = 0;
35337 size_t result;
35338
35339 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35340 {
35341 PyThreadState* __tstate = wxPyBeginAllowThreads();
35342 result = (size_t)wxDisplay::GetCount();
35343 wxPyEndAllowThreads(__tstate);
35344 if (PyErr_Occurred()) SWIG_fail;
35345 }
35346 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35347 return resultobj;
35348 fail:
35349 return NULL;
35350 }
35351
35352
35353 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35354 PyObject *resultobj = 0;
35355 wxPoint *arg1 = 0 ;
35356 int result;
35357 wxPoint temp1 ;
35358 PyObject * obj0 = 0 ;
35359 char * kwnames[] = {
35360 (char *) "pt", NULL
35361 };
35362
35363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35364 {
35365 arg1 = &temp1;
35366 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35367 }
35368 {
35369 PyThreadState* __tstate = wxPyBeginAllowThreads();
35370 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35371 wxPyEndAllowThreads(__tstate);
35372 if (PyErr_Occurred()) SWIG_fail;
35373 }
35374 resultobj = SWIG_From_int(static_cast< int >(result));
35375 return resultobj;
35376 fail:
35377 return NULL;
35378 }
35379
35380
35381 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35382 PyObject *resultobj = 0;
35383 wxWindow *arg1 = (wxWindow *) 0 ;
35384 int result;
35385 void *argp1 = 0 ;
35386 int res1 = 0 ;
35387 PyObject * obj0 = 0 ;
35388 char * kwnames[] = {
35389 (char *) "window", NULL
35390 };
35391
35392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35394 if (!SWIG_IsOK(res1)) {
35395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35396 }
35397 arg1 = reinterpret_cast< wxWindow * >(argp1);
35398 {
35399 PyThreadState* __tstate = wxPyBeginAllowThreads();
35400 result = (int)wxDisplay::GetFromWindow(arg1);
35401 wxPyEndAllowThreads(__tstate);
35402 if (PyErr_Occurred()) SWIG_fail;
35403 }
35404 resultobj = SWIG_From_int(static_cast< int >(result));
35405 return resultobj;
35406 fail:
35407 return NULL;
35408 }
35409
35410
35411 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35412 PyObject *resultobj = 0;
35413 wxDisplay *arg1 = (wxDisplay *) 0 ;
35414 bool result;
35415 void *argp1 = 0 ;
35416 int res1 = 0 ;
35417 PyObject *swig_obj[1] ;
35418
35419 if (!args) SWIG_fail;
35420 swig_obj[0] = args;
35421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35422 if (!SWIG_IsOK(res1)) {
35423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35424 }
35425 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35426 {
35427 PyThreadState* __tstate = wxPyBeginAllowThreads();
35428 result = (bool)((wxDisplay const *)arg1)->IsOk();
35429 wxPyEndAllowThreads(__tstate);
35430 if (PyErr_Occurred()) SWIG_fail;
35431 }
35432 {
35433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35434 }
35435 return resultobj;
35436 fail:
35437 return NULL;
35438 }
35439
35440
35441 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35442 PyObject *resultobj = 0;
35443 wxDisplay *arg1 = (wxDisplay *) 0 ;
35444 wxRect result;
35445 void *argp1 = 0 ;
35446 int res1 = 0 ;
35447 PyObject *swig_obj[1] ;
35448
35449 if (!args) SWIG_fail;
35450 swig_obj[0] = args;
35451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35452 if (!SWIG_IsOK(res1)) {
35453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35454 }
35455 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35456 {
35457 PyThreadState* __tstate = wxPyBeginAllowThreads();
35458 result = ((wxDisplay const *)arg1)->GetGeometry();
35459 wxPyEndAllowThreads(__tstate);
35460 if (PyErr_Occurred()) SWIG_fail;
35461 }
35462 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35463 return resultobj;
35464 fail:
35465 return NULL;
35466 }
35467
35468
35469 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35470 PyObject *resultobj = 0;
35471 wxDisplay *arg1 = (wxDisplay *) 0 ;
35472 wxRect result;
35473 void *argp1 = 0 ;
35474 int res1 = 0 ;
35475 PyObject *swig_obj[1] ;
35476
35477 if (!args) SWIG_fail;
35478 swig_obj[0] = args;
35479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35480 if (!SWIG_IsOK(res1)) {
35481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35482 }
35483 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 result = ((wxDisplay const *)arg1)->GetClientArea();
35487 wxPyEndAllowThreads(__tstate);
35488 if (PyErr_Occurred()) SWIG_fail;
35489 }
35490 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35491 return resultobj;
35492 fail:
35493 return NULL;
35494 }
35495
35496
35497 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35498 PyObject *resultobj = 0;
35499 wxDisplay *arg1 = (wxDisplay *) 0 ;
35500 wxString result;
35501 void *argp1 = 0 ;
35502 int res1 = 0 ;
35503 PyObject *swig_obj[1] ;
35504
35505 if (!args) SWIG_fail;
35506 swig_obj[0] = args;
35507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35508 if (!SWIG_IsOK(res1)) {
35509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35510 }
35511 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 result = ((wxDisplay const *)arg1)->GetName();
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 {
35519 #if wxUSE_UNICODE
35520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35521 #else
35522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35523 #endif
35524 }
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35532 PyObject *resultobj = 0;
35533 wxDisplay *arg1 = (wxDisplay *) 0 ;
35534 bool result;
35535 void *argp1 = 0 ;
35536 int res1 = 0 ;
35537 PyObject *swig_obj[1] ;
35538
35539 if (!args) SWIG_fail;
35540 swig_obj[0] = args;
35541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35542 if (!SWIG_IsOK(res1)) {
35543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35544 }
35545 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35546 {
35547 PyThreadState* __tstate = wxPyBeginAllowThreads();
35548 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35549 wxPyEndAllowThreads(__tstate);
35550 if (PyErr_Occurred()) SWIG_fail;
35551 }
35552 {
35553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35554 }
35555 return resultobj;
35556 fail:
35557 return NULL;
35558 }
35559
35560
35561 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35562 PyObject *resultobj = 0;
35563 wxDisplay *arg1 = (wxDisplay *) 0 ;
35564 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35565 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35566 PyObject *result = 0 ;
35567 void *argp1 = 0 ;
35568 int res1 = 0 ;
35569 void *argp2 = 0 ;
35570 int res2 = 0 ;
35571 PyObject * obj0 = 0 ;
35572 PyObject * obj1 = 0 ;
35573 char * kwnames[] = {
35574 (char *) "self",(char *) "mode", NULL
35575 };
35576
35577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35579 if (!SWIG_IsOK(res1)) {
35580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35581 }
35582 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35583 if (obj1) {
35584 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35585 if (!SWIG_IsOK(res2)) {
35586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35587 }
35588 if (!argp2) {
35589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35590 }
35591 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35592 }
35593 {
35594 PyThreadState* __tstate = wxPyBeginAllowThreads();
35595 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35596 wxPyEndAllowThreads(__tstate);
35597 if (PyErr_Occurred()) SWIG_fail;
35598 }
35599 resultobj = result;
35600 return resultobj;
35601 fail:
35602 return NULL;
35603 }
35604
35605
35606 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35607 PyObject *resultobj = 0;
35608 wxDisplay *arg1 = (wxDisplay *) 0 ;
35609 wxVideoMode result;
35610 void *argp1 = 0 ;
35611 int res1 = 0 ;
35612 PyObject *swig_obj[1] ;
35613
35614 if (!args) SWIG_fail;
35615 swig_obj[0] = args;
35616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35617 if (!SWIG_IsOK(res1)) {
35618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35619 }
35620 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35621 {
35622 PyThreadState* __tstate = wxPyBeginAllowThreads();
35623 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35624 wxPyEndAllowThreads(__tstate);
35625 if (PyErr_Occurred()) SWIG_fail;
35626 }
35627 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35628 return resultobj;
35629 fail:
35630 return NULL;
35631 }
35632
35633
35634 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35635 PyObject *resultobj = 0;
35636 wxDisplay *arg1 = (wxDisplay *) 0 ;
35637 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35638 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35639 bool result;
35640 void *argp1 = 0 ;
35641 int res1 = 0 ;
35642 void *argp2 = 0 ;
35643 int res2 = 0 ;
35644 PyObject * obj0 = 0 ;
35645 PyObject * obj1 = 0 ;
35646 char * kwnames[] = {
35647 (char *) "self",(char *) "mode", NULL
35648 };
35649
35650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35652 if (!SWIG_IsOK(res1)) {
35653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35654 }
35655 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35656 if (obj1) {
35657 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35658 if (!SWIG_IsOK(res2)) {
35659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35660 }
35661 if (!argp2) {
35662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35663 }
35664 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35665 }
35666 {
35667 PyThreadState* __tstate = wxPyBeginAllowThreads();
35668 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35669 wxPyEndAllowThreads(__tstate);
35670 if (PyErr_Occurred()) SWIG_fail;
35671 }
35672 {
35673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35674 }
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35682 PyObject *resultobj = 0;
35683 wxDisplay *arg1 = (wxDisplay *) 0 ;
35684 void *argp1 = 0 ;
35685 int res1 = 0 ;
35686 PyObject *swig_obj[1] ;
35687
35688 if (!args) SWIG_fail;
35689 swig_obj[0] = args;
35690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35691 if (!SWIG_IsOK(res1)) {
35692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35693 }
35694 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 wxDisplay_ResetMode(arg1);
35698 wxPyEndAllowThreads(__tstate);
35699 if (PyErr_Occurred()) SWIG_fail;
35700 }
35701 resultobj = SWIG_Py_Void();
35702 return resultobj;
35703 fail:
35704 return NULL;
35705 }
35706
35707
35708 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35709 PyObject *obj;
35710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35711 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35712 return SWIG_Py_Void();
35713 }
35714
35715 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35716 return SWIG_Python_InitShadowInstance(args);
35717 }
35718
35719 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35720 PyObject *resultobj = 0;
35721 wxStandardPaths *result = 0 ;
35722
35723 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35724 {
35725 PyThreadState* __tstate = wxPyBeginAllowThreads();
35726 result = (wxStandardPaths *)wxStandardPaths_Get();
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35731 return resultobj;
35732 fail:
35733 return NULL;
35734 }
35735
35736
35737 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35738 PyObject *resultobj = 0;
35739 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35740 wxString result;
35741 void *argp1 = 0 ;
35742 int res1 = 0 ;
35743 PyObject *swig_obj[1] ;
35744
35745 if (!args) SWIG_fail;
35746 swig_obj[0] = args;
35747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35748 if (!SWIG_IsOK(res1)) {
35749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35750 }
35751 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35752 {
35753 PyThreadState* __tstate = wxPyBeginAllowThreads();
35754 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35755 wxPyEndAllowThreads(__tstate);
35756 if (PyErr_Occurred()) SWIG_fail;
35757 }
35758 {
35759 #if wxUSE_UNICODE
35760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35761 #else
35762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35763 #endif
35764 }
35765 return resultobj;
35766 fail:
35767 return NULL;
35768 }
35769
35770
35771 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35772 PyObject *resultobj = 0;
35773 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35774 wxString result;
35775 void *argp1 = 0 ;
35776 int res1 = 0 ;
35777 PyObject *swig_obj[1] ;
35778
35779 if (!args) SWIG_fail;
35780 swig_obj[0] = args;
35781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35782 if (!SWIG_IsOK(res1)) {
35783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35784 }
35785 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35786 {
35787 PyThreadState* __tstate = wxPyBeginAllowThreads();
35788 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35789 wxPyEndAllowThreads(__tstate);
35790 if (PyErr_Occurred()) SWIG_fail;
35791 }
35792 {
35793 #if wxUSE_UNICODE
35794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35795 #else
35796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35797 #endif
35798 }
35799 return resultobj;
35800 fail:
35801 return NULL;
35802 }
35803
35804
35805 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35806 PyObject *resultobj = 0;
35807 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35808 wxString result;
35809 void *argp1 = 0 ;
35810 int res1 = 0 ;
35811 PyObject *swig_obj[1] ;
35812
35813 if (!args) SWIG_fail;
35814 swig_obj[0] = args;
35815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35816 if (!SWIG_IsOK(res1)) {
35817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35818 }
35819 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35820 {
35821 PyThreadState* __tstate = wxPyBeginAllowThreads();
35822 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35823 wxPyEndAllowThreads(__tstate);
35824 if (PyErr_Occurred()) SWIG_fail;
35825 }
35826 {
35827 #if wxUSE_UNICODE
35828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35829 #else
35830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35831 #endif
35832 }
35833 return resultobj;
35834 fail:
35835 return NULL;
35836 }
35837
35838
35839 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35840 PyObject *resultobj = 0;
35841 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35842 wxString result;
35843 void *argp1 = 0 ;
35844 int res1 = 0 ;
35845 PyObject *swig_obj[1] ;
35846
35847 if (!args) SWIG_fail;
35848 swig_obj[0] = args;
35849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35850 if (!SWIG_IsOK(res1)) {
35851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35852 }
35853 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35854 {
35855 PyThreadState* __tstate = wxPyBeginAllowThreads();
35856 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35857 wxPyEndAllowThreads(__tstate);
35858 if (PyErr_Occurred()) SWIG_fail;
35859 }
35860 {
35861 #if wxUSE_UNICODE
35862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35863 #else
35864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35865 #endif
35866 }
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35874 PyObject *resultobj = 0;
35875 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35876 wxString result;
35877 void *argp1 = 0 ;
35878 int res1 = 0 ;
35879 PyObject *swig_obj[1] ;
35880
35881 if (!args) SWIG_fail;
35882 swig_obj[0] = args;
35883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35884 if (!SWIG_IsOK(res1)) {
35885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35886 }
35887 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35888 {
35889 PyThreadState* __tstate = wxPyBeginAllowThreads();
35890 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 {
35895 #if wxUSE_UNICODE
35896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35897 #else
35898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35899 #endif
35900 }
35901 return resultobj;
35902 fail:
35903 return NULL;
35904 }
35905
35906
35907 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35908 PyObject *resultobj = 0;
35909 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35910 wxString result;
35911 void *argp1 = 0 ;
35912 int res1 = 0 ;
35913 PyObject *swig_obj[1] ;
35914
35915 if (!args) SWIG_fail;
35916 swig_obj[0] = args;
35917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35918 if (!SWIG_IsOK(res1)) {
35919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35920 }
35921 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35922 {
35923 PyThreadState* __tstate = wxPyBeginAllowThreads();
35924 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35925 wxPyEndAllowThreads(__tstate);
35926 if (PyErr_Occurred()) SWIG_fail;
35927 }
35928 {
35929 #if wxUSE_UNICODE
35930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35931 #else
35932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35933 #endif
35934 }
35935 return resultobj;
35936 fail:
35937 return NULL;
35938 }
35939
35940
35941 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35942 PyObject *resultobj = 0;
35943 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35944 wxString result;
35945 void *argp1 = 0 ;
35946 int res1 = 0 ;
35947 PyObject *swig_obj[1] ;
35948
35949 if (!args) SWIG_fail;
35950 swig_obj[0] = args;
35951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35952 if (!SWIG_IsOK(res1)) {
35953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35954 }
35955 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35959 wxPyEndAllowThreads(__tstate);
35960 if (PyErr_Occurred()) SWIG_fail;
35961 }
35962 {
35963 #if wxUSE_UNICODE
35964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35965 #else
35966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35967 #endif
35968 }
35969 return resultobj;
35970 fail:
35971 return NULL;
35972 }
35973
35974
35975 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35976 PyObject *resultobj = 0;
35977 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35978 wxString result;
35979 void *argp1 = 0 ;
35980 int res1 = 0 ;
35981 PyObject *swig_obj[1] ;
35982
35983 if (!args) SWIG_fail;
35984 swig_obj[0] = args;
35985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35986 if (!SWIG_IsOK(res1)) {
35987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35988 }
35989 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35990 {
35991 PyThreadState* __tstate = wxPyBeginAllowThreads();
35992 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35993 wxPyEndAllowThreads(__tstate);
35994 if (PyErr_Occurred()) SWIG_fail;
35995 }
35996 {
35997 #if wxUSE_UNICODE
35998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35999 #else
36000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36001 #endif
36002 }
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36010 PyObject *resultobj = 0;
36011 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36012 wxString *arg2 = 0 ;
36013 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
36014 wxString result;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017 bool temp2 = false ;
36018 int val3 ;
36019 int ecode3 = 0 ;
36020 PyObject * obj0 = 0 ;
36021 PyObject * obj1 = 0 ;
36022 PyObject * obj2 = 0 ;
36023 char * kwnames[] = {
36024 (char *) "self",(char *) "lang",(char *) "category", NULL
36025 };
36026
36027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36029 if (!SWIG_IsOK(res1)) {
36030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36031 }
36032 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36033 {
36034 arg2 = wxString_in_helper(obj1);
36035 if (arg2 == NULL) SWIG_fail;
36036 temp2 = true;
36037 }
36038 if (obj2) {
36039 ecode3 = SWIG_AsVal_int(obj2, &val3);
36040 if (!SWIG_IsOK(ecode3)) {
36041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
36042 }
36043 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
36044 }
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
36048 wxPyEndAllowThreads(__tstate);
36049 if (PyErr_Occurred()) SWIG_fail;
36050 }
36051 {
36052 #if wxUSE_UNICODE
36053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36054 #else
36055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36056 #endif
36057 }
36058 {
36059 if (temp2)
36060 delete arg2;
36061 }
36062 return resultobj;
36063 fail:
36064 {
36065 if (temp2)
36066 delete arg2;
36067 }
36068 return NULL;
36069 }
36070
36071
36072 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36073 PyObject *resultobj = 0;
36074 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36075 wxString result;
36076 void *argp1 = 0 ;
36077 int res1 = 0 ;
36078 PyObject *swig_obj[1] ;
36079
36080 if (!args) SWIG_fail;
36081 swig_obj[0] = args;
36082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36083 if (!SWIG_IsOK(res1)) {
36084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36085 }
36086 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 {
36094 #if wxUSE_UNICODE
36095 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36096 #else
36097 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36098 #endif
36099 }
36100 return resultobj;
36101 fail:
36102 return NULL;
36103 }
36104
36105
36106 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36107 PyObject *resultobj = 0;
36108 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36109 wxString *arg2 = 0 ;
36110 void *argp1 = 0 ;
36111 int res1 = 0 ;
36112 bool temp2 = false ;
36113 PyObject * obj0 = 0 ;
36114 PyObject * obj1 = 0 ;
36115 char * kwnames[] = {
36116 (char *) "self",(char *) "prefix", NULL
36117 };
36118
36119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
36120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36121 if (!SWIG_IsOK(res1)) {
36122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36123 }
36124 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36125 {
36126 arg2 = wxString_in_helper(obj1);
36127 if (arg2 == NULL) SWIG_fail;
36128 temp2 = true;
36129 }
36130 {
36131 PyThreadState* __tstate = wxPyBeginAllowThreads();
36132 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
36133 wxPyEndAllowThreads(__tstate);
36134 if (PyErr_Occurred()) SWIG_fail;
36135 }
36136 resultobj = SWIG_Py_Void();
36137 {
36138 if (temp2)
36139 delete arg2;
36140 }
36141 return resultobj;
36142 fail:
36143 {
36144 if (temp2)
36145 delete arg2;
36146 }
36147 return NULL;
36148 }
36149
36150
36151 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36152 PyObject *resultobj = 0;
36153 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36154 wxString result;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 PyObject *swig_obj[1] ;
36158
36159 if (!args) SWIG_fail;
36160 swig_obj[0] = args;
36161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36162 if (!SWIG_IsOK(res1)) {
36163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36164 }
36165 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36166 {
36167 PyThreadState* __tstate = wxPyBeginAllowThreads();
36168 result = wxStandardPaths_GetInstallPrefix(arg1);
36169 wxPyEndAllowThreads(__tstate);
36170 if (PyErr_Occurred()) SWIG_fail;
36171 }
36172 {
36173 #if wxUSE_UNICODE
36174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36175 #else
36176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36177 #endif
36178 }
36179 return resultobj;
36180 fail:
36181 return NULL;
36182 }
36183
36184
36185 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36186 PyObject *obj;
36187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36188 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36189 return SWIG_Py_Void();
36190 }
36191
36192 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36193 PyObject *resultobj = 0;
36194 wxEventType arg1 ;
36195 wxPowerEvent *result = 0 ;
36196 int val1 ;
36197 int ecode1 = 0 ;
36198 PyObject * obj0 = 0 ;
36199 char * kwnames[] = {
36200 (char *) "evtType", NULL
36201 };
36202
36203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36204 ecode1 = SWIG_AsVal_int(obj0, &val1);
36205 if (!SWIG_IsOK(ecode1)) {
36206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36207 }
36208 arg1 = static_cast< wxEventType >(val1);
36209 {
36210 PyThreadState* __tstate = wxPyBeginAllowThreads();
36211 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36212 wxPyEndAllowThreads(__tstate);
36213 if (PyErr_Occurred()) SWIG_fail;
36214 }
36215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36216 return resultobj;
36217 fail:
36218 return NULL;
36219 }
36220
36221
36222 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36223 PyObject *resultobj = 0;
36224 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36225 void *argp1 = 0 ;
36226 int res1 = 0 ;
36227 PyObject *swig_obj[1] ;
36228
36229 if (!args) SWIG_fail;
36230 swig_obj[0] = args;
36231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36232 if (!SWIG_IsOK(res1)) {
36233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36234 }
36235 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36236 {
36237 PyThreadState* __tstate = wxPyBeginAllowThreads();
36238 (arg1)->Veto();
36239 wxPyEndAllowThreads(__tstate);
36240 if (PyErr_Occurred()) SWIG_fail;
36241 }
36242 resultobj = SWIG_Py_Void();
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36250 PyObject *resultobj = 0;
36251 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36252 bool result;
36253 void *argp1 = 0 ;
36254 int res1 = 0 ;
36255 PyObject *swig_obj[1] ;
36256
36257 if (!args) SWIG_fail;
36258 swig_obj[0] = args;
36259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36260 if (!SWIG_IsOK(res1)) {
36261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36262 }
36263 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36264 {
36265 PyThreadState* __tstate = wxPyBeginAllowThreads();
36266 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36267 wxPyEndAllowThreads(__tstate);
36268 if (PyErr_Occurred()) SWIG_fail;
36269 }
36270 {
36271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36272 }
36273 return resultobj;
36274 fail:
36275 return NULL;
36276 }
36277
36278
36279 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36280 PyObject *obj;
36281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36282 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36283 return SWIG_Py_Void();
36284 }
36285
36286 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36287 return SWIG_Python_InitShadowInstance(args);
36288 }
36289
36290 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36291 PyObject *resultobj = 0;
36292 wxPowerType result;
36293
36294 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36295 {
36296 PyThreadState* __tstate = wxPyBeginAllowThreads();
36297 result = (wxPowerType)wxGetPowerType();
36298 wxPyEndAllowThreads(__tstate);
36299 if (PyErr_Occurred()) SWIG_fail;
36300 }
36301 resultobj = SWIG_From_int(static_cast< int >(result));
36302 return resultobj;
36303 fail:
36304 return NULL;
36305 }
36306
36307
36308 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36309 PyObject *resultobj = 0;
36310 wxBatteryState result;
36311
36312 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36313 {
36314 PyThreadState* __tstate = wxPyBeginAllowThreads();
36315 result = (wxBatteryState)wxGetBatteryState();
36316 wxPyEndAllowThreads(__tstate);
36317 if (PyErr_Occurred()) SWIG_fail;
36318 }
36319 resultobj = SWIG_From_int(static_cast< int >(result));
36320 return resultobj;
36321 fail:
36322 return NULL;
36323 }
36324
36325
36326 static PyMethodDef SwigMethods[] = {
36327 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36331 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36332 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36334 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36335 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36336 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36337 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36342 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36343 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36344 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36346 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36347 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36349 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36350 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36351 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36352 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36353 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36354 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36356 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36357 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36358 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36359 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36366 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36367 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36368 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36369 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36370 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36371 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36373 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36374 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36385 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36386 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36387 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36388 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36389 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36390 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36391 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36392 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36393 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36395 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36396 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36397 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36398 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36399 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36402 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36405 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36406 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36407 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36408 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36409 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36410 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36411 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36412 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36413 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36414 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36415 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36416 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36419 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36420 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36425 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36426 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36427 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36428 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36429 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36430 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36431 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36432 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36433 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36434 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36435 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36436 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36437 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36438 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36440 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36441 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36444 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36445 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36447 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36448 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36449 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36450 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36451 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36452 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36453 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36454 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36455 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36458 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36461 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36462 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36463 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36464 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36465 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36467 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36468 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36469 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36471 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36472 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36473 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36475 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36476 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36477 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36478 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36479 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36480 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36481 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36482 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36483 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36484 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36486 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36489 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36494 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36495 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36496 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36497 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36498 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36499 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36500 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36501 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36502 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36503 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36504 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36505 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36506 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36507 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36508 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36509 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36510 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36511 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36512 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36514 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36515 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36516 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36519 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36520 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36523 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36525 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36526 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36527 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36528 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36529 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36530 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36531 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36532 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36534 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36535 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36536 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36537 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36538 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36540 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36541 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36542 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36543 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36544 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36546 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36547 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36548 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36549 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36551 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36552 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36555 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
36557 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36561 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36562 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36563 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36564 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36565 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36567 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36568 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36569 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36570 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36571 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36572 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36573 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36574 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36575 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36577 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36578 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36579 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36580 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36581 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36584 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36585 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36586 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36588 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36589 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36593 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36594 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36595 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36596 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36597 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36598 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36599 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36600 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36601 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36606 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36607 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36608 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36614 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36616 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36617 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36618 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36619 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36620 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36621 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36622 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36623 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36629 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36630 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36631 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36632 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36633 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36634 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36635 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36636 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36637 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36638 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36639 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36640 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36641 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36643 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36644 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36645 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36646 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36647 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36648 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36649 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36650 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36654 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36655 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36656 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36657 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36658 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36659 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36660 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36661 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36662 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36663 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36665 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36666 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36667 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36668 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36669 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36670 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36671 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36672 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36673 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36674 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36675 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36676 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36677 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36678 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36679 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36680 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36681 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36682 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36683 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36684 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36685 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36686 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36687 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36688 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36689 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36690 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36691 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36692 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36693 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36694 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36696 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36697 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36698 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36700 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36701 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36702 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36703 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36704 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36710 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36711 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36712 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36716 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36717 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36718 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36719 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36720 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36721 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36723 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36725 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36726 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36727 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36728 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36731 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36732 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36735 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36736 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36737 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36738 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36739 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36740 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36741 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36742 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36743 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36744 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36745 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36747 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36748 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36749 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36750 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36751 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36752 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36753 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36759 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36761 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36762 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36763 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36764 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36765 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36766 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36770 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36771 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36773 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36775 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36776 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36777 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36778 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36779 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36781 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36782 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36783 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36784 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36786 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36787 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36788 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36789 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36790 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36793 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36794 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36796 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36797 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36799 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36805 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36814 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36820 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36822 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36824 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36825 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36826 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36827 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36831 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36832 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36834 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36835 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36836 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36838 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36839 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36840 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36841 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36842 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36843 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36844 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36845 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36846 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36847 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36848 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36849 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36850 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36854 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36857 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36858 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36859 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36863 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36864 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36865 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36866 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36871 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36872 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36873 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36874 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36875 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36877 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36878 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36881 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36882 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36883 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36885 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36886 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36889 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36891 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36896 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36898 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36900 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36902 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36903 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36904 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36905 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36906 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36907 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36909 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36910 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36911 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36913 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36914 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36915 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36916 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36917 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36918 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36919 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36920 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36922 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36923 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36926 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36927 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36928 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36929 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36930 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36931 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36933 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36935 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36936 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36938 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36939 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36940 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36941 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36942 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36943 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36944 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36945 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36946 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36947 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36948 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36949 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36950 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36951 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36952 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36953 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36954 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36955 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36956 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36957 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36958 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36959 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36960 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36961 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36962 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36963 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36964 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36965 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36966 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36967 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36968 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36969 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36970 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36971 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36972 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36973 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36974 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36975 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36976 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36977 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36978 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36979 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36980 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36982 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36983 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36984 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36985 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36986 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36988 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36989 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36990 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36991 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36992 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36993 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36994 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36995 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36996 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36997 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36998 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36999 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
37000 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
37001 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
37002 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37003 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
37004 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37005 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
37006 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
37007 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
37008 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
37009 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
37010 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
37011 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37012 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
37013 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
37014 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37015 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
37016 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37017 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
37018 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37019 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
37020 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
37021 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
37022 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
37023 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
37024 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
37025 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
37026 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
37027 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
37028 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
37029 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
37030 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
37031 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
37032 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
37033 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37034 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37035 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
37036 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37037 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37038 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37039 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
37040 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37041 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37042 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37043 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37044 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37045 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37046 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37047 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
37048 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
37049 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
37050 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
37051 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
37052 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
37053 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37054 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37055 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
37056 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
37057 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
37058 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
37059 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
37060 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
37061 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
37062 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
37063 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
37064 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
37065 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37066 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
37067 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37068 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
37069 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
37070 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
37071 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37072 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
37073 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37074 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
37075 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37076 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
37077 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
37078 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37079 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
37080 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
37081 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37082 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37083 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
37084 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
37085 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
37086 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37087 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
37088 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
37089 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
37090 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37091 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
37092 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
37093 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
37094 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
37095 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
37096 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37097 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37098 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
37099 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
37100 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37101 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
37102 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37103 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
37104 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
37105 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37106 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37107 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
37108 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
37109 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
37110 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
37111 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
37112 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
37113 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
37114 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
37115 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37116 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
37117 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
37118 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
37119 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
37120 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
37121 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
37122 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
37123 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
37124 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
37125 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
37126 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
37127 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
37128 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
37129 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
37130 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
37131 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
37132 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37133 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
37134 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37135 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
37136 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37137 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37138 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
37139 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
37140 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
37141 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37142 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37143 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
37144 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
37145 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37146 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37147 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37148 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
37149 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37150 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
37151 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
37152 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
37153 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
37154 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
37155 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
37156 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37157 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
37158 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37159 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37160 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
37161 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37162 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37163 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
37164 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
37165 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
37166 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37167 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
37168 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37169 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37170 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
37171 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37172 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37173 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
37174 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
37175 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
37176 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
37177 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
37178 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
37179 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
37180 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
37181 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37182 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37183 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37184 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37185 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37186 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37187 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37188 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37189 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37190 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37191 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37192 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37193 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37194 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37195 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37196 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37197 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37198 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37199 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37200 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37201 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37202 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37203 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37204 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37205 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37206 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37207 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37208 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37209 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37210 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37211 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37212 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37213 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37214 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37215 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37216 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37217 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37218 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37219 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37220 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37221 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37222 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37223 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37224 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37225 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37226 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37227 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37228 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37229 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37230 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37231 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37232 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37233 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37234 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37235 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37236 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37237 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37238 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37239 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37240 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37241 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37242 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37243 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37244 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37245 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37246 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37247 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37248 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37249 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37250 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37251 { NULL, NULL, 0, NULL }
37252 };
37253
37254
37255 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37256
37257 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37258 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37259 }
37260 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37261 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37262 }
37263 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37264 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37265 }
37266 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37267 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37268 }
37269 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37270 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37271 }
37272 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37273 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37274 }
37275 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37276 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37277 }
37278 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37279 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37280 }
37281 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37282 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37283 }
37284 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37285 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37286 }
37287 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37288 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37289 }
37290 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
37291 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
37292 }
37293 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37294 return (void *)((wxEvent *) ((wxPyEvent *) x));
37295 }
37296 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37297 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37298 }
37299 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37300 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37301 }
37302 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37303 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37304 }
37305 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37306 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37307 }
37308 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37309 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37310 }
37311 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37312 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37313 }
37314 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37315 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37316 }
37317 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37318 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37319 }
37320 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37321 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37322 }
37323 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37324 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37325 }
37326 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37327 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37328 }
37329 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37330 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37331 }
37332 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37334 }
37335 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37337 }
37338 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37339 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37340 }
37341 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37342 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37343 }
37344 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37345 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37346 }
37347 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37348 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37349 }
37350 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37351 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37352 }
37353 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37354 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37355 }
37356 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37357 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37358 }
37359 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37360 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37361 }
37362 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37363 return (void *)((wxEvent *) ((wxShowEvent *) x));
37364 }
37365 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37366 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37367 }
37368 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37369 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37370 }
37371 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37372 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37373 }
37374 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37375 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37376 }
37377 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37378 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37379 }
37380 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37381 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37382 }
37383 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37384 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37385 }
37386 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37387 return (void *)((wxConfigBase *) ((wxConfig *) x));
37388 }
37389 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37390 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37391 }
37392 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37393 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37394 }
37395 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37396 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37397 }
37398 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37399 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37400 }
37401 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37402 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37403 }
37404 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37405 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37406 }
37407 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37408 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37409 }
37410 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37411 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37412 }
37413 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37414 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37415 }
37416 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37417 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37418 }
37419 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37420 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37421 }
37422 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37423 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37424 }
37425 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37426 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37427 }
37428 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37429 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37430 }
37431 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37432 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37433 }
37434 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37435 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37436 }
37437 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37438 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37439 }
37440 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37441 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37442 }
37443 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37444 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37445 }
37446 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37447 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37448 }
37449 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37450 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37451 }
37452 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37453 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37454 }
37455 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37456 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37457 }
37458 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37459 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37460 }
37461 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37462 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37463 }
37464 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37465 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37466 }
37467 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37468 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37469 }
37470 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37471 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37472 }
37473 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37474 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37475 }
37476 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37477 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37478 }
37479 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37480 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37481 }
37482 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37483 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37484 }
37485 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37486 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37487 }
37488 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37489 return (void *)((wxObject *) ((wxSizerItem *) x));
37490 }
37491 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37492 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37493 }
37494 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37496 }
37497 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37498 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37499 }
37500 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37501 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37502 }
37503 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37504 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37505 }
37506 static void *_p_wxSizerTo_p_wxObject(void *x) {
37507 return (void *)((wxObject *) ((wxSizer *) x));
37508 }
37509 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37510 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37511 }
37512 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37513 return (void *)((wxObject *) ((wxFileHistory *) x));
37514 }
37515 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37517 }
37518 static void *_p_wxEventTo_p_wxObject(void *x) {
37519 return (void *)((wxObject *) ((wxEvent *) x));
37520 }
37521 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37522 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37523 }
37524 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37525 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37526 }
37527 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37528 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37529 }
37530 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37532 }
37533 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37534 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37535 }
37536 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37537 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37538 }
37539 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37540 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37541 }
37542 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37543 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37544 }
37545 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37546 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37547 }
37548 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37549 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37550 }
37551 static void *_p_wxControlTo_p_wxObject(void *x) {
37552 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37553 }
37554 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37555 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37556 }
37557 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37558 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37559 }
37560 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37561 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37562 }
37563 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37564 return (void *)((wxObject *) ((wxFSFile *) x));
37565 }
37566 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37567 return (void *)((wxObject *) ((wxClipboard *) x));
37568 }
37569 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37570 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37571 }
37572 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37573 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37574 }
37575 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37576 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37577 }
37578 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37579 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37580 }
37581 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37582 return (void *)((wxObject *) ((wxToolTip *) x));
37583 }
37584 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37585 return (void *)((wxObject *) ((wxMenuItem *) x));
37586 }
37587 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37588 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37589 }
37590 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37591 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37592 }
37593 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37594 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37595 }
37596 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37597 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37598 }
37599 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37600 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37601 }
37602 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37603 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37604 }
37605 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37606 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37607 }
37608 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37609 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37610 }
37611 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37612 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37613 }
37614 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37615 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37616 }
37617 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37618 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37619 }
37620 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37621 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37622 }
37623 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37624 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37625 }
37626 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37627 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37628 }
37629 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37630 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37631 }
37632 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37633 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37634 }
37635 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37636 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37637 }
37638 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37639 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37640 }
37641 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37642 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37643 }
37644 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37645 return (void *)((wxObject *) ((wxImageHandler *) x));
37646 }
37647 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37648 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37649 }
37650 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37651 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37652 }
37653 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37654 return (void *)((wxObject *) ((wxEvtHandler *) x));
37655 }
37656 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
37657 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
37658 }
37659 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37660 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37661 }
37662 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37663 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37664 }
37665 static void *_p_wxImageTo_p_wxObject(void *x) {
37666 return (void *)((wxObject *) ((wxImage *) x));
37667 }
37668 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37669 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37670 }
37671 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37672 return (void *)((wxObject *) ((wxSystemOptions *) x));
37673 }
37674 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37675 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37676 }
37677 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37678 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37679 }
37680 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37681 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37682 }
37683 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37684 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37685 }
37686 static void *_p_wxWindowTo_p_wxObject(void *x) {
37687 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37688 }
37689 static void *_p_wxMenuTo_p_wxObject(void *x) {
37690 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37691 }
37692 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37693 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37694 }
37695 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37696 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37697 }
37698 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37699 return (void *)((wxObject *) ((wxFileSystem *) x));
37700 }
37701 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37702 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37703 }
37704 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37705 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37706 }
37707 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37708 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37709 }
37710 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37711 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37712 }
37713 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37714 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37715 }
37716 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37717 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37718 }
37719 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37720 return (void *)((wxObject *) ((wxBusyInfo *) x));
37721 }
37722 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37723 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37724 }
37725 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37726 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37727 }
37728 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37729 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37730 }
37731 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37732 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37733 }
37734 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37735 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37736 }
37737 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37738 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37739 }
37740 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37741 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37742 }
37743 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37744 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37745 }
37746 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37747 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37748 }
37749 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37750 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37751 }
37752 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37753 return (void *)((wxLog *) ((wxLogBuffer *) x));
37754 }
37755 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37756 return (void *)((wxLog *) ((wxLogStderr *) x));
37757 }
37758 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37759 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37760 }
37761 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37762 return (void *)((wxLog *) ((wxLogWindow *) x));
37763 }
37764 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37765 return (void *)((wxLog *) ((wxLogChain *) x));
37766 }
37767 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37768 return (void *)((wxLog *) ((wxLogGui *) x));
37769 }
37770 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37771 return (void *)((wxLog *) ((wxPyLog *) x));
37772 }
37773 static void *_p_wxControlTo_p_wxWindow(void *x) {
37774 return (void *)((wxWindow *) ((wxControl *) x));
37775 }
37776 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37777 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37778 }
37779 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37780 return (void *)((wxWindow *) ((wxMenuBar *) x));
37781 }
37782 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37783 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37784 }
37785 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37786 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37787 }
37788 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37789 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};
37790 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37791 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37792 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37793 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37794 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37795 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37796 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37797 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37798 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37799 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37800 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37801 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37802 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37803 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37804 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37805 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37806 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37807 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37808 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37809 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37810 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37811 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37812 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37813 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37814 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37815 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37816 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37817 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37818 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37819 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37820 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37821 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37822 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37823 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37824 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37825 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37826 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37827 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37828 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37829 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37830 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37831 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
37832 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37833 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37834 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37835 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37836 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37837 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37838 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37839 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37840 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37841 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37842 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37843 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37844 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37845 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37846 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37847 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37848 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37849 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37850 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37851 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37852 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37853 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37854 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37855 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37856 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37857 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37858 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37859 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37860 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37861 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37862 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37863 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37864 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37865 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37866 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37867 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37868 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37869 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37870 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37871 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37872 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37873 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37874 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37875 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37876 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37877 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37878 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37879 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37880 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37881 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37882 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37883 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37884 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37885 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37886 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37887 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37888 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37889 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37890 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37891 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37892 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37893 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37894 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37895 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37896 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37897 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37898 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37899 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37900 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37901 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37902 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37903 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37904 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37905 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37906 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37907 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37908 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37909 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37910 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37911 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37912 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37913 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37914 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37915 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37916 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37917 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37918 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37919 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37920 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37921 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37922 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37923 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37924 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37925 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37926 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37927 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37928 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37929 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37930 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37931 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37932 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37933 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37934 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37935 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37936 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37937 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37938 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37939 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37940 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37941 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37942 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37943 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37944 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37945 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37946 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37947 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37948 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37949 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37950 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37951 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37952 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37953 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37954 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37955 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37956 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37957 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37958 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37959 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37960
37961 static swig_type_info *swig_type_initial[] = {
37962 &_swigt__p_char,
37963 &_swigt__p_form_ops_t,
37964 &_swigt__p_int,
37965 &_swigt__p_unsigned_char,
37966 &_swigt__p_unsigned_int,
37967 &_swigt__p_unsigned_long,
37968 &_swigt__p_void,
37969 &_swigt__p_wxANIHandler,
37970 &_swigt__p_wxAcceleratorTable,
37971 &_swigt__p_wxActivateEvent,
37972 &_swigt__p_wxArrayString,
37973 &_swigt__p_wxBMPHandler,
37974 &_swigt__p_wxBitmap,
37975 &_swigt__p_wxBitmapDataObject,
37976 &_swigt__p_wxBoxSizer,
37977 &_swigt__p_wxBusyCursor,
37978 &_swigt__p_wxBusyInfo,
37979 &_swigt__p_wxCURHandler,
37980 &_swigt__p_wxCaret,
37981 &_swigt__p_wxChar,
37982 &_swigt__p_wxChildFocusEvent,
37983 &_swigt__p_wxClipboard,
37984 &_swigt__p_wxClipboardLocker,
37985 &_swigt__p_wxClipboardTextEvent,
37986 &_swigt__p_wxCloseEvent,
37987 &_swigt__p_wxColour,
37988 &_swigt__p_wxCommandEvent,
37989 &_swigt__p_wxConfig,
37990 &_swigt__p_wxConfigBase,
37991 &_swigt__p_wxConfigPathChanger,
37992 &_swigt__p_wxContextMenuEvent,
37993 &_swigt__p_wxControl,
37994 &_swigt__p_wxControlWithItems,
37995 &_swigt__p_wxCursor,
37996 &_swigt__p_wxCustomDataObject,
37997 &_swigt__p_wxDC,
37998 &_swigt__p_wxDataFormat,
37999 &_swigt__p_wxDataObject,
38000 &_swigt__p_wxDataObjectComposite,
38001 &_swigt__p_wxDataObjectSimple,
38002 &_swigt__p_wxDateEvent,
38003 &_swigt__p_wxDateSpan,
38004 &_swigt__p_wxDateTime,
38005 &_swigt__p_wxDateTime__TimeZone,
38006 &_swigt__p_wxDisplay,
38007 &_swigt__p_wxDisplayChangedEvent,
38008 &_swigt__p_wxDropFilesEvent,
38009 &_swigt__p_wxDuplexMode,
38010 &_swigt__p_wxEraseEvent,
38011 &_swigt__p_wxEvent,
38012 &_swigt__p_wxEvtHandler,
38013 &_swigt__p_wxFSFile,
38014 &_swigt__p_wxFileConfig,
38015 &_swigt__p_wxFileDataObject,
38016 &_swigt__p_wxFileHistory,
38017 &_swigt__p_wxFileSystem,
38018 &_swigt__p_wxFileType,
38019 &_swigt__p_wxFileTypeInfo,
38020 &_swigt__p_wxFlexGridSizer,
38021 &_swigt__p_wxFocusEvent,
38022 &_swigt__p_wxFont,
38023 &_swigt__p_wxFrame,
38024 &_swigt__p_wxGBSizerItem,
38025 &_swigt__p_wxGIFHandler,
38026 &_swigt__p_wxGridBagSizer,
38027 &_swigt__p_wxGridSizer,
38028 &_swigt__p_wxICOHandler,
38029 &_swigt__p_wxIcon,
38030 &_swigt__p_wxIconizeEvent,
38031 &_swigt__p_wxIdleEvent,
38032 &_swigt__p_wxImage,
38033 &_swigt__p_wxImageHandler,
38034 &_swigt__p_wxIndividualLayoutConstraint,
38035 &_swigt__p_wxInitDialogEvent,
38036 &_swigt__p_wxJPEGHandler,
38037 &_swigt__p_wxJoystick,
38038 &_swigt__p_wxJoystickEvent,
38039 &_swigt__p_wxKeyEvent,
38040 &_swigt__p_wxKillError,
38041 &_swigt__p_wxLayoutConstraints,
38042 &_swigt__p_wxLog,
38043 &_swigt__p_wxLogBuffer,
38044 &_swigt__p_wxLogChain,
38045 &_swigt__p_wxLogGui,
38046 &_swigt__p_wxLogNull,
38047 &_swigt__p_wxLogStderr,
38048 &_swigt__p_wxLogTextCtrl,
38049 &_swigt__p_wxLogWindow,
38050 &_swigt__p_wxMaximizeEvent,
38051 &_swigt__p_wxMenu,
38052 &_swigt__p_wxMenuBar,
38053 &_swigt__p_wxMenuEvent,
38054 &_swigt__p_wxMenuItem,
38055 &_swigt__p_wxMetafile,
38056 &_swigt__p_wxMetafileDataObject,
38057 &_swigt__p_wxMimeTypesManager,
38058 &_swigt__p_wxMouseCaptureChangedEvent,
38059 &_swigt__p_wxMouseCaptureLostEvent,
38060 &_swigt__p_wxMouseEvent,
38061 &_swigt__p_wxMouseState,
38062 &_swigt__p_wxMoveEvent,
38063 &_swigt__p_wxMutexGuiLocker,
38064 &_swigt__p_wxNavigationKeyEvent,
38065 &_swigt__p_wxNcPaintEvent,
38066 &_swigt__p_wxNotifyEvent,
38067 &_swigt__p_wxObject,
38068 &_swigt__p_wxOutputStream,
38069 &_swigt__p_wxPCXHandler,
38070 &_swigt__p_wxPNGHandler,
38071 &_swigt__p_wxPNMHandler,
38072 &_swigt__p_wxPaintEvent,
38073 &_swigt__p_wxPaletteChangedEvent,
38074 &_swigt__p_wxPaperSize,
38075 &_swigt__p_wxPoint,
38076 &_swigt__p_wxPowerEvent,
38077 &_swigt__p_wxProcessEvent,
38078 &_swigt__p_wxPyApp,
38079 &_swigt__p_wxPyArtProvider,
38080 &_swigt__p_wxPyBitmapDataObject,
38081 &_swigt__p_wxPyCommandEvent,
38082 &_swigt__p_wxPyDataObjectSimple,
38083 &_swigt__p_wxPyDropSource,
38084 &_swigt__p_wxPyDropTarget,
38085 &_swigt__p_wxPyEvent,
38086 &_swigt__p_wxPyFileDropTarget,
38087 &_swigt__p_wxPyImageHandler,
38088 &_swigt__p_wxPyLog,
38089 &_swigt__p_wxPyProcess,
38090 &_swigt__p_wxPySizer,
38091 &_swigt__p_wxPyTextDataObject,
38092 &_swigt__p_wxPyTextDropTarget,
38093 &_swigt__p_wxPyTimer,
38094 &_swigt__p_wxPyTipProvider,
38095 &_swigt__p_wxPyValidator,
38096 &_swigt__p_wxQueryNewPaletteEvent,
38097 &_swigt__p_wxRect,
38098 &_swigt__p_wxScrollEvent,
38099 &_swigt__p_wxScrollWinEvent,
38100 &_swigt__p_wxSetCursorEvent,
38101 &_swigt__p_wxShowEvent,
38102 &_swigt__p_wxSingleInstanceChecker,
38103 &_swigt__p_wxSize,
38104 &_swigt__p_wxSizeEvent,
38105 &_swigt__p_wxSizer,
38106 &_swigt__p_wxSizerItem,
38107 &_swigt__p_wxSound,
38108 &_swigt__p_wxStandardPaths,
38109 &_swigt__p_wxStaticBoxSizer,
38110 &_swigt__p_wxStdDialogButtonSizer,
38111 &_swigt__p_wxStopWatch,
38112 &_swigt__p_wxString,
38113 &_swigt__p_wxSysColourChangedEvent,
38114 &_swigt__p_wxSystemOptions,
38115 &_swigt__p_wxSystemSettings,
38116 &_swigt__p_wxTIFFHandler,
38117 &_swigt__p_wxTextCtrl,
38118 &_swigt__p_wxTextDataObject,
38119 &_swigt__p_wxTimeSpan,
38120 &_swigt__p_wxTimer,
38121 &_swigt__p_wxTimerEvent,
38122 &_swigt__p_wxTimerRunner,
38123 &_swigt__p_wxTipProvider,
38124 &_swigt__p_wxToolTip,
38125 &_swigt__p_wxURLDataObject,
38126 &_swigt__p_wxUpdateUIEvent,
38127 &_swigt__p_wxValidator,
38128 &_swigt__p_wxVideoMode,
38129 &_swigt__p_wxWindow,
38130 &_swigt__p_wxWindowCreateEvent,
38131 &_swigt__p_wxWindowDestroyEvent,
38132 &_swigt__p_wxWindowDisabler,
38133 &_swigt__p_wxXPMHandler,
38134 };
38135
38136 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
38137 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
38138 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
38139 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
38140 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
38141 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
38142 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
38143 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
38144 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
38145 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}};
38146 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
38147 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
38148 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
38149 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
38150 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
38151 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
38152 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
38153 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
38154 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}};
38155 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
38156 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
38157 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
38158 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
38159 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
38160 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}};
38161 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
38162 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}};
38163 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
38164 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
38165 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
38166 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
38167 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
38168 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38169 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38170 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
38171 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
38172 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
38173 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
38174 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
38175 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
38176 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
38177 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
38178 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
38179 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
38180 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
38181 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
38182 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38183 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38184 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
38185 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38186 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
38187 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
38188 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38189 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38190 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38191 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38192 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38193 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38194 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38195 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38196 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38197 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38198 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38199 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38200 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38201 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38202 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38203 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38204 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38205 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38206 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
38207 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38208 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38209 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38210 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38211 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38212 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38213 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}};
38214 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38215 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38216 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38217 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38218 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38219 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38220 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38221 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38222 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38223 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38224 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38225 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}};
38226 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38227 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38228 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38229 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38230 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38231 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38232 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38233 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38234 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
38235 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38236 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38237 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38238 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38239 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38240 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38241 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38242 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38243 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38244 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38245 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38246 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38247 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38248 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38249 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38250 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38251 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38252 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38253 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38254 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38255 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38256 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38257 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38258 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38259 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38260 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38261 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38262 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38263 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38264 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38265 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38266 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38267 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38268 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38269 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
38270 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38271 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38272 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38273 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38274 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38275 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38276 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38277 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38278 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38279 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}};
38280 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38281 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38282 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38283 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38284 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38285 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38286 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38287 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38288 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38289 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38290 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38291 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38292 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38293 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38294 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38295 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38296 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38297 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}};
38298 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38299 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38300 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38301 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38302 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}};
38303 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38304 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38305 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38306 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}};
38307 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38308
38309 static swig_cast_info *swig_cast_initial[] = {
38310 _swigc__p_char,
38311 _swigc__p_form_ops_t,
38312 _swigc__p_int,
38313 _swigc__p_unsigned_char,
38314 _swigc__p_unsigned_int,
38315 _swigc__p_unsigned_long,
38316 _swigc__p_void,
38317 _swigc__p_wxANIHandler,
38318 _swigc__p_wxAcceleratorTable,
38319 _swigc__p_wxActivateEvent,
38320 _swigc__p_wxArrayString,
38321 _swigc__p_wxBMPHandler,
38322 _swigc__p_wxBitmap,
38323 _swigc__p_wxBitmapDataObject,
38324 _swigc__p_wxBoxSizer,
38325 _swigc__p_wxBusyCursor,
38326 _swigc__p_wxBusyInfo,
38327 _swigc__p_wxCURHandler,
38328 _swigc__p_wxCaret,
38329 _swigc__p_wxChar,
38330 _swigc__p_wxChildFocusEvent,
38331 _swigc__p_wxClipboard,
38332 _swigc__p_wxClipboardLocker,
38333 _swigc__p_wxClipboardTextEvent,
38334 _swigc__p_wxCloseEvent,
38335 _swigc__p_wxColour,
38336 _swigc__p_wxCommandEvent,
38337 _swigc__p_wxConfig,
38338 _swigc__p_wxConfigBase,
38339 _swigc__p_wxConfigPathChanger,
38340 _swigc__p_wxContextMenuEvent,
38341 _swigc__p_wxControl,
38342 _swigc__p_wxControlWithItems,
38343 _swigc__p_wxCursor,
38344 _swigc__p_wxCustomDataObject,
38345 _swigc__p_wxDC,
38346 _swigc__p_wxDataFormat,
38347 _swigc__p_wxDataObject,
38348 _swigc__p_wxDataObjectComposite,
38349 _swigc__p_wxDataObjectSimple,
38350 _swigc__p_wxDateEvent,
38351 _swigc__p_wxDateSpan,
38352 _swigc__p_wxDateTime,
38353 _swigc__p_wxDateTime__TimeZone,
38354 _swigc__p_wxDisplay,
38355 _swigc__p_wxDisplayChangedEvent,
38356 _swigc__p_wxDropFilesEvent,
38357 _swigc__p_wxDuplexMode,
38358 _swigc__p_wxEraseEvent,
38359 _swigc__p_wxEvent,
38360 _swigc__p_wxEvtHandler,
38361 _swigc__p_wxFSFile,
38362 _swigc__p_wxFileConfig,
38363 _swigc__p_wxFileDataObject,
38364 _swigc__p_wxFileHistory,
38365 _swigc__p_wxFileSystem,
38366 _swigc__p_wxFileType,
38367 _swigc__p_wxFileTypeInfo,
38368 _swigc__p_wxFlexGridSizer,
38369 _swigc__p_wxFocusEvent,
38370 _swigc__p_wxFont,
38371 _swigc__p_wxFrame,
38372 _swigc__p_wxGBSizerItem,
38373 _swigc__p_wxGIFHandler,
38374 _swigc__p_wxGridBagSizer,
38375 _swigc__p_wxGridSizer,
38376 _swigc__p_wxICOHandler,
38377 _swigc__p_wxIcon,
38378 _swigc__p_wxIconizeEvent,
38379 _swigc__p_wxIdleEvent,
38380 _swigc__p_wxImage,
38381 _swigc__p_wxImageHandler,
38382 _swigc__p_wxIndividualLayoutConstraint,
38383 _swigc__p_wxInitDialogEvent,
38384 _swigc__p_wxJPEGHandler,
38385 _swigc__p_wxJoystick,
38386 _swigc__p_wxJoystickEvent,
38387 _swigc__p_wxKeyEvent,
38388 _swigc__p_wxKillError,
38389 _swigc__p_wxLayoutConstraints,
38390 _swigc__p_wxLog,
38391 _swigc__p_wxLogBuffer,
38392 _swigc__p_wxLogChain,
38393 _swigc__p_wxLogGui,
38394 _swigc__p_wxLogNull,
38395 _swigc__p_wxLogStderr,
38396 _swigc__p_wxLogTextCtrl,
38397 _swigc__p_wxLogWindow,
38398 _swigc__p_wxMaximizeEvent,
38399 _swigc__p_wxMenu,
38400 _swigc__p_wxMenuBar,
38401 _swigc__p_wxMenuEvent,
38402 _swigc__p_wxMenuItem,
38403 _swigc__p_wxMetafile,
38404 _swigc__p_wxMetafileDataObject,
38405 _swigc__p_wxMimeTypesManager,
38406 _swigc__p_wxMouseCaptureChangedEvent,
38407 _swigc__p_wxMouseCaptureLostEvent,
38408 _swigc__p_wxMouseEvent,
38409 _swigc__p_wxMouseState,
38410 _swigc__p_wxMoveEvent,
38411 _swigc__p_wxMutexGuiLocker,
38412 _swigc__p_wxNavigationKeyEvent,
38413 _swigc__p_wxNcPaintEvent,
38414 _swigc__p_wxNotifyEvent,
38415 _swigc__p_wxObject,
38416 _swigc__p_wxOutputStream,
38417 _swigc__p_wxPCXHandler,
38418 _swigc__p_wxPNGHandler,
38419 _swigc__p_wxPNMHandler,
38420 _swigc__p_wxPaintEvent,
38421 _swigc__p_wxPaletteChangedEvent,
38422 _swigc__p_wxPaperSize,
38423 _swigc__p_wxPoint,
38424 _swigc__p_wxPowerEvent,
38425 _swigc__p_wxProcessEvent,
38426 _swigc__p_wxPyApp,
38427 _swigc__p_wxPyArtProvider,
38428 _swigc__p_wxPyBitmapDataObject,
38429 _swigc__p_wxPyCommandEvent,
38430 _swigc__p_wxPyDataObjectSimple,
38431 _swigc__p_wxPyDropSource,
38432 _swigc__p_wxPyDropTarget,
38433 _swigc__p_wxPyEvent,
38434 _swigc__p_wxPyFileDropTarget,
38435 _swigc__p_wxPyImageHandler,
38436 _swigc__p_wxPyLog,
38437 _swigc__p_wxPyProcess,
38438 _swigc__p_wxPySizer,
38439 _swigc__p_wxPyTextDataObject,
38440 _swigc__p_wxPyTextDropTarget,
38441 _swigc__p_wxPyTimer,
38442 _swigc__p_wxPyTipProvider,
38443 _swigc__p_wxPyValidator,
38444 _swigc__p_wxQueryNewPaletteEvent,
38445 _swigc__p_wxRect,
38446 _swigc__p_wxScrollEvent,
38447 _swigc__p_wxScrollWinEvent,
38448 _swigc__p_wxSetCursorEvent,
38449 _swigc__p_wxShowEvent,
38450 _swigc__p_wxSingleInstanceChecker,
38451 _swigc__p_wxSize,
38452 _swigc__p_wxSizeEvent,
38453 _swigc__p_wxSizer,
38454 _swigc__p_wxSizerItem,
38455 _swigc__p_wxSound,
38456 _swigc__p_wxStandardPaths,
38457 _swigc__p_wxStaticBoxSizer,
38458 _swigc__p_wxStdDialogButtonSizer,
38459 _swigc__p_wxStopWatch,
38460 _swigc__p_wxString,
38461 _swigc__p_wxSysColourChangedEvent,
38462 _swigc__p_wxSystemOptions,
38463 _swigc__p_wxSystemSettings,
38464 _swigc__p_wxTIFFHandler,
38465 _swigc__p_wxTextCtrl,
38466 _swigc__p_wxTextDataObject,
38467 _swigc__p_wxTimeSpan,
38468 _swigc__p_wxTimer,
38469 _swigc__p_wxTimerEvent,
38470 _swigc__p_wxTimerRunner,
38471 _swigc__p_wxTipProvider,
38472 _swigc__p_wxToolTip,
38473 _swigc__p_wxURLDataObject,
38474 _swigc__p_wxUpdateUIEvent,
38475 _swigc__p_wxValidator,
38476 _swigc__p_wxVideoMode,
38477 _swigc__p_wxWindow,
38478 _swigc__p_wxWindowCreateEvent,
38479 _swigc__p_wxWindowDestroyEvent,
38480 _swigc__p_wxWindowDisabler,
38481 _swigc__p_wxXPMHandler,
38482 };
38483
38484
38485 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38486
38487 static swig_const_info swig_const_table[] = {
38488 {0, 0, 0, 0.0, 0, 0}};
38489
38490 #ifdef __cplusplus
38491 }
38492 #endif
38493 /* -----------------------------------------------------------------------------
38494 * Type initialization:
38495 * This problem is tough by the requirement that no dynamic
38496 * memory is used. Also, since swig_type_info structures store pointers to
38497 * swig_cast_info structures and swig_cast_info structures store pointers back
38498 * to swig_type_info structures, we need some lookup code at initialization.
38499 * The idea is that swig generates all the structures that are needed.
38500 * The runtime then collects these partially filled structures.
38501 * The SWIG_InitializeModule function takes these initial arrays out of
38502 * swig_module, and does all the lookup, filling in the swig_module.types
38503 * array with the correct data and linking the correct swig_cast_info
38504 * structures together.
38505 *
38506 * The generated swig_type_info structures are assigned staticly to an initial
38507 * array. We just loop though that array, and handle each type individually.
38508 * First we lookup if this type has been already loaded, and if so, use the
38509 * loaded structure instead of the generated one. Then we have to fill in the
38510 * cast linked list. The cast data is initially stored in something like a
38511 * two-dimensional array. Each row corresponds to a type (there are the same
38512 * number of rows as there are in the swig_type_initial array). Each entry in
38513 * a column is one of the swig_cast_info structures for that type.
38514 * The cast_initial array is actually an array of arrays, because each row has
38515 * a variable number of columns. So to actually build the cast linked list,
38516 * we find the array of casts associated with the type, and loop through it
38517 * adding the casts to the list. The one last trick we need to do is making
38518 * sure the type pointer in the swig_cast_info struct is correct.
38519 *
38520 * First off, we lookup the cast->type name to see if it is already loaded.
38521 * There are three cases to handle:
38522 * 1) If the cast->type has already been loaded AND the type we are adding
38523 * casting info to has not been loaded (it is in this module), THEN we
38524 * replace the cast->type pointer with the type pointer that has already
38525 * been loaded.
38526 * 2) If BOTH types (the one we are adding casting info to, and the
38527 * cast->type) are loaded, THEN the cast info has already been loaded by
38528 * the previous module so we just ignore it.
38529 * 3) Finally, if cast->type has not already been loaded, then we add that
38530 * swig_cast_info to the linked list (because the cast->type) pointer will
38531 * be correct.
38532 * ----------------------------------------------------------------------------- */
38533
38534 #ifdef __cplusplus
38535 extern "C" {
38536 #if 0
38537 } /* c-mode */
38538 #endif
38539 #endif
38540
38541 #if 0
38542 #define SWIGRUNTIME_DEBUG
38543 #endif
38544
38545 SWIGRUNTIME void
38546 SWIG_InitializeModule(void *clientdata) {
38547 size_t i;
38548 swig_module_info *module_head;
38549 static int init_run = 0;
38550
38551 clientdata = clientdata;
38552
38553 if (init_run) return;
38554 init_run = 1;
38555
38556 /* Initialize the swig_module */
38557 swig_module.type_initial = swig_type_initial;
38558 swig_module.cast_initial = swig_cast_initial;
38559
38560 /* Try and load any already created modules */
38561 module_head = SWIG_GetModule(clientdata);
38562 if (module_head) {
38563 swig_module.next = module_head->next;
38564 module_head->next = &swig_module;
38565 } else {
38566 /* This is the first module loaded */
38567 swig_module.next = &swig_module;
38568 SWIG_SetModule(clientdata, &swig_module);
38569 }
38570
38571 /* Now work on filling in swig_module.types */
38572 #ifdef SWIGRUNTIME_DEBUG
38573 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38574 #endif
38575 for (i = 0; i < swig_module.size; ++i) {
38576 swig_type_info *type = 0;
38577 swig_type_info *ret;
38578 swig_cast_info *cast;
38579
38580 #ifdef SWIGRUNTIME_DEBUG
38581 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38582 #endif
38583
38584 /* if there is another module already loaded */
38585 if (swig_module.next != &swig_module) {
38586 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38587 }
38588 if (type) {
38589 /* Overwrite clientdata field */
38590 #ifdef SWIGRUNTIME_DEBUG
38591 printf("SWIG_InitializeModule: found type %s\n", type->name);
38592 #endif
38593 if (swig_module.type_initial[i]->clientdata) {
38594 type->clientdata = swig_module.type_initial[i]->clientdata;
38595 #ifdef SWIGRUNTIME_DEBUG
38596 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38597 #endif
38598 }
38599 } else {
38600 type = swig_module.type_initial[i];
38601 }
38602
38603 /* Insert casting types */
38604 cast = swig_module.cast_initial[i];
38605 while (cast->type) {
38606 /* Don't need to add information already in the list */
38607 ret = 0;
38608 #ifdef SWIGRUNTIME_DEBUG
38609 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38610 #endif
38611 if (swig_module.next != &swig_module) {
38612 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38613 #ifdef SWIGRUNTIME_DEBUG
38614 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38615 #endif
38616 }
38617 if (ret) {
38618 if (type == swig_module.type_initial[i]) {
38619 #ifdef SWIGRUNTIME_DEBUG
38620 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38621 #endif
38622 cast->type = ret;
38623 ret = 0;
38624 } else {
38625 /* Check for casting already in the list */
38626 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38627 #ifdef SWIGRUNTIME_DEBUG
38628 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38629 #endif
38630 if (!ocast) ret = 0;
38631 }
38632 }
38633
38634 if (!ret) {
38635 #ifdef SWIGRUNTIME_DEBUG
38636 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38637 #endif
38638 if (type->cast) {
38639 type->cast->prev = cast;
38640 cast->next = type->cast;
38641 }
38642 type->cast = cast;
38643 }
38644 cast++;
38645 }
38646 /* Set entry in modules->types array equal to the type */
38647 swig_module.types[i] = type;
38648 }
38649 swig_module.types[i] = 0;
38650
38651 #ifdef SWIGRUNTIME_DEBUG
38652 printf("**** SWIG_InitializeModule: Cast List ******\n");
38653 for (i = 0; i < swig_module.size; ++i) {
38654 int j = 0;
38655 swig_cast_info *cast = swig_module.cast_initial[i];
38656 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38657 while (cast->type) {
38658 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38659 cast++;
38660 ++j;
38661 }
38662 printf("---- Total casts: %d\n",j);
38663 }
38664 printf("**** SWIG_InitializeModule: Cast List ******\n");
38665 #endif
38666 }
38667
38668 /* This function will propagate the clientdata field of type to
38669 * any new swig_type_info structures that have been added into the list
38670 * of equivalent types. It is like calling
38671 * SWIG_TypeClientData(type, clientdata) a second time.
38672 */
38673 SWIGRUNTIME void
38674 SWIG_PropagateClientData(void) {
38675 size_t i;
38676 swig_cast_info *equiv;
38677 static int init_run = 0;
38678
38679 if (init_run) return;
38680 init_run = 1;
38681
38682 for (i = 0; i < swig_module.size; i++) {
38683 if (swig_module.types[i]->clientdata) {
38684 equiv = swig_module.types[i]->cast;
38685 while (equiv) {
38686 if (!equiv->converter) {
38687 if (equiv->type && !equiv->type->clientdata)
38688 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38689 }
38690 equiv = equiv->next;
38691 }
38692 }
38693 }
38694 }
38695
38696 #ifdef __cplusplus
38697 #if 0
38698 {
38699 /* c-mode */
38700 #endif
38701 }
38702 #endif
38703
38704
38705
38706 #ifdef __cplusplus
38707 extern "C" {
38708 #endif
38709
38710 /* Python-specific SWIG API */
38711 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38712 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38713 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38714
38715 /* -----------------------------------------------------------------------------
38716 * global variable support code.
38717 * ----------------------------------------------------------------------------- */
38718
38719 typedef struct swig_globalvar {
38720 char *name; /* Name of global variable */
38721 PyObject *(*get_attr)(void); /* Return the current value */
38722 int (*set_attr)(PyObject *); /* Set the value */
38723 struct swig_globalvar *next;
38724 } swig_globalvar;
38725
38726 typedef struct swig_varlinkobject {
38727 PyObject_HEAD
38728 swig_globalvar *vars;
38729 } swig_varlinkobject;
38730
38731 SWIGINTERN PyObject *
38732 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38733 return PyString_FromString("<Swig global variables>");
38734 }
38735
38736 SWIGINTERN PyObject *
38737 swig_varlink_str(swig_varlinkobject *v) {
38738 PyObject *str = PyString_FromString("(");
38739 swig_globalvar *var;
38740 for (var = v->vars; var; var=var->next) {
38741 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38742 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38743 }
38744 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38745 return str;
38746 }
38747
38748 SWIGINTERN int
38749 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38750 PyObject *str = swig_varlink_str(v);
38751 fprintf(fp,"Swig global variables ");
38752 fprintf(fp,"%s\n", PyString_AsString(str));
38753 Py_DECREF(str);
38754 return 0;
38755 }
38756
38757 SWIGINTERN void
38758 swig_varlink_dealloc(swig_varlinkobject *v) {
38759 swig_globalvar *var = v->vars;
38760 while (var) {
38761 swig_globalvar *n = var->next;
38762 free(var->name);
38763 free(var);
38764 var = n;
38765 }
38766 }
38767
38768 SWIGINTERN PyObject *
38769 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38770 PyObject *res = NULL;
38771 swig_globalvar *var = v->vars;
38772 while (var) {
38773 if (strcmp(var->name,n) == 0) {
38774 res = (*var->get_attr)();
38775 break;
38776 }
38777 var = var->next;
38778 }
38779 if (res == NULL && !PyErr_Occurred()) {
38780 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38781 }
38782 return res;
38783 }
38784
38785 SWIGINTERN int
38786 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38787 int res = 1;
38788 swig_globalvar *var = v->vars;
38789 while (var) {
38790 if (strcmp(var->name,n) == 0) {
38791 res = (*var->set_attr)(p);
38792 break;
38793 }
38794 var = var->next;
38795 }
38796 if (res == 1 && !PyErr_Occurred()) {
38797 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38798 }
38799 return res;
38800 }
38801
38802 SWIGINTERN PyTypeObject*
38803 swig_varlink_type(void) {
38804 static char varlink__doc__[] = "Swig var link object";
38805 static PyTypeObject varlink_type;
38806 static int type_init = 0;
38807 if (!type_init) {
38808 const PyTypeObject tmp
38809 = {
38810 PyObject_HEAD_INIT(NULL)
38811 0, /* Number of items in variable part (ob_size) */
38812 (char *)"swigvarlink", /* Type name (tp_name) */
38813 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38814 0, /* Itemsize (tp_itemsize) */
38815 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38816 (printfunc) swig_varlink_print, /* Print (tp_print) */
38817 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38818 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38819 0, /* tp_compare */
38820 (reprfunc) swig_varlink_repr, /* tp_repr */
38821 0, /* tp_as_number */
38822 0, /* tp_as_sequence */
38823 0, /* tp_as_mapping */
38824 0, /* tp_hash */
38825 0, /* tp_call */
38826 (reprfunc)swig_varlink_str, /* tp_str */
38827 0, /* tp_getattro */
38828 0, /* tp_setattro */
38829 0, /* tp_as_buffer */
38830 0, /* tp_flags */
38831 varlink__doc__, /* tp_doc */
38832 0, /* tp_traverse */
38833 0, /* tp_clear */
38834 0, /* tp_richcompare */
38835 0, /* tp_weaklistoffset */
38836 #if PY_VERSION_HEX >= 0x02020000
38837 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38838 #endif
38839 #if PY_VERSION_HEX >= 0x02030000
38840 0, /* tp_del */
38841 #endif
38842 #ifdef COUNT_ALLOCS
38843 0,0,0,0 /* tp_alloc -> tp_next */
38844 #endif
38845 };
38846 varlink_type = tmp;
38847 varlink_type.ob_type = &PyType_Type;
38848 type_init = 1;
38849 }
38850 return &varlink_type;
38851 }
38852
38853 /* Create a variable linking object for use later */
38854 SWIGINTERN PyObject *
38855 SWIG_Python_newvarlink(void) {
38856 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38857 if (result) {
38858 result->vars = 0;
38859 }
38860 return ((PyObject*) result);
38861 }
38862
38863 SWIGINTERN void
38864 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38865 swig_varlinkobject *v = (swig_varlinkobject *) p;
38866 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38867 if (gv) {
38868 size_t size = strlen(name)+1;
38869 gv->name = (char *)malloc(size);
38870 if (gv->name) {
38871 strncpy(gv->name,name,size);
38872 gv->get_attr = get_attr;
38873 gv->set_attr = set_attr;
38874 gv->next = v->vars;
38875 }
38876 }
38877 v->vars = gv;
38878 }
38879
38880 SWIGINTERN PyObject *
38881 SWIG_globals() {
38882 static PyObject *_SWIG_globals = 0;
38883 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38884 return _SWIG_globals;
38885 }
38886
38887 /* -----------------------------------------------------------------------------
38888 * constants/methods manipulation
38889 * ----------------------------------------------------------------------------- */
38890
38891 /* Install Constants */
38892 SWIGINTERN void
38893 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38894 PyObject *obj = 0;
38895 size_t i;
38896 for (i = 0; constants[i].type; ++i) {
38897 switch(constants[i].type) {
38898 case SWIG_PY_POINTER:
38899 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38900 break;
38901 case SWIG_PY_BINARY:
38902 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38903 break;
38904 default:
38905 obj = 0;
38906 break;
38907 }
38908 if (obj) {
38909 PyDict_SetItemString(d, constants[i].name, obj);
38910 Py_DECREF(obj);
38911 }
38912 }
38913 }
38914
38915 /* -----------------------------------------------------------------------------*/
38916 /* Fix SwigMethods to carry the callback ptrs when needed */
38917 /* -----------------------------------------------------------------------------*/
38918
38919 SWIGINTERN void
38920 SWIG_Python_FixMethods(PyMethodDef *methods,
38921 swig_const_info *const_table,
38922 swig_type_info **types,
38923 swig_type_info **types_initial) {
38924 size_t i;
38925 for (i = 0; methods[i].ml_name; ++i) {
38926 const char *c = methods[i].ml_doc;
38927 if (c && (c = strstr(c, "swig_ptr: "))) {
38928 int j;
38929 swig_const_info *ci = 0;
38930 const char *name = c + 10;
38931 for (j = 0; const_table[j].type; ++j) {
38932 if (strncmp(const_table[j].name, name,
38933 strlen(const_table[j].name)) == 0) {
38934 ci = &(const_table[j]);
38935 break;
38936 }
38937 }
38938 if (ci) {
38939 size_t shift = (ci->ptype) - types;
38940 swig_type_info *ty = types_initial[shift];
38941 size_t ldoc = (c - methods[i].ml_doc);
38942 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38943 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38944 if (ndoc) {
38945 char *buff = ndoc;
38946 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38947 if (ptr) {
38948 strncpy(buff, methods[i].ml_doc, ldoc);
38949 buff += ldoc;
38950 strncpy(buff, "swig_ptr: ", 10);
38951 buff += 10;
38952 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38953 methods[i].ml_doc = ndoc;
38954 }
38955 }
38956 }
38957 }
38958 }
38959 }
38960
38961 #ifdef __cplusplus
38962 }
38963 #endif
38964
38965 /* -----------------------------------------------------------------------------*
38966 * Partial Init method
38967 * -----------------------------------------------------------------------------*/
38968
38969 #ifdef __cplusplus
38970 extern "C"
38971 #endif
38972 SWIGEXPORT void SWIG_init(void) {
38973 PyObject *m, *d;
38974
38975 /* Fix SwigMethods to carry the callback ptrs when needed */
38976 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38977
38978 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38979 d = PyModule_GetDict(m);
38980
38981 SWIG_InitializeModule(0);
38982 SWIG_InstallConstants(d,swig_const_table);
38983
38984
38985 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38986 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38987 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38988 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38989 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38990 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38991 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38992 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38993 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38994 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38995 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38996 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38997 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38998 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38999 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
39000 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
39001 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
39002 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
39003 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
39004 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
39005 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
39006 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
39007 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
39008 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
39009 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
39010 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
39011 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
39012 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
39013 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
39014 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
39015 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
39016 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
39017 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
39018 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
39019 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
39020 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
39021 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
39022 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
39023 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
39024 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
39025 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
39026 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
39027 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
39028 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
39029 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
39030 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
39031 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
39032 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
39033 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
39034 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
39035 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
39036 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
39037 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
39038 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
39039 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
39040 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
39041 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
39042 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
39043 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
39044 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
39045 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
39046 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
39047 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
39048 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
39049 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
39050 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
39051 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
39052 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
39053 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
39054 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
39055 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
39056 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
39057 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
39058 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
39059 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
39060 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
39061 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
39062 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
39063 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
39064 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
39065 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
39066 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
39067 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
39068 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
39069 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
39070 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
39071 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
39072 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
39073 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
39074 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
39075 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
39076 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
39077 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
39078 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
39079 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
39080 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
39081 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
39082 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
39083 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
39084 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
39085 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
39086 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
39087 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
39088 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
39089 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
39090 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
39091 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
39092 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
39093 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
39094 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
39095 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
39096 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
39097 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
39098 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
39099 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
39100 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
39101 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
39102 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
39103 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
39104 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
39105 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
39106 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
39107 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
39108 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
39109 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
39110 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
39111 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
39112 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
39113 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
39114 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
39115 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
39116 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
39117 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
39118 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
39119 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
39120 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
39121 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
39122
39123 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
39124
39125 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
39126 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
39127 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
39128 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
39129 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
39130 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
39131 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
39132 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
39133 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
39134 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
39135 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
39136 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
39137 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
39138 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
39139 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
39140 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
39141 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
39142 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
39143 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
39144 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
39145 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
39146 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
39147 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
39148 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
39149 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
39150 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
39151 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
39152 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
39153 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
39154 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
39155 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
39156 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
39157 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
39158 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
39159 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
39160 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
39161 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
39162 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
39163 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
39164 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
39165 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
39166 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
39167 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
39168 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
39169 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
39170 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
39171 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
39172 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
39173 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
39174 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
39175 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
39176 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
39177 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
39178
39179 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
39180
39181 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
39182 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
39183 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
39184 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
39185 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
39186 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
39187 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
39188 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
39189 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
39190 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
39191 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
39192 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
39193 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
39194 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
39195 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
39196 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
39197 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
39198 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
39199 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
39200 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
39201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
39202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
39203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
39204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
39205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
39206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
39207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
39208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
39209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
39210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
39211 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
39212 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
39213 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
39214 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
39215 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39216 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39217 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39218 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39219 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39220 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39221 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39222 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39223 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39224 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39225 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39226 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39227 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39240 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39241 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39242 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39243 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39244 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39245 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39246 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39247 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39248 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39249 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39250 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39251 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39252 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39253 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39254 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39255 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39256 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39257
39258 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39259
39260 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39261 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39262 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39263 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39264 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39265 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39266 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39267 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39268 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39269 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39270 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39271 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39272 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39273 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39274 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39275 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39276 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39277 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39278 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39279 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39280 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39281 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39282 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39283 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39284 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39285 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39286 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39287 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39288 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39289 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39290 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39291 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39292 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39293 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39294 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39295 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39296 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39297 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39298 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39299 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39300 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39301 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39302 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39303 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39304 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39305 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39306 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39307 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39308 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39309 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39310 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39311 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39312 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39313 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39314 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39315 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39316 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39317 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39318 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39319 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39320 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39321 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39322 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39323 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39324 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39325 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39326 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39327 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39328 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39329 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39330 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39331 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39332 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39333 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39334 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39335 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39336 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39337 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39338 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39339 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39340 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39341 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39342 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39343 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39344 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39345 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39346 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39347 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39348 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39349 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39350 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39351 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39352 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39353 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39354 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39355 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39356 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39357 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39358 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39359 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39360 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39361 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39362 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39363 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39364 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39365 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39366 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39367 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39368 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39369 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39370 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39371 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39372 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39373 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39374 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39375 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39376 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39377 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39378 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39379 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39380 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39381 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39382 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39383 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39384 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39385 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39386 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39387 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39388 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39389 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39390 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39391 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39392 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39393 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39394 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39395 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39396 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39397 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39398 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39399 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39400 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39401 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39402 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39403 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39404 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39405 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39406 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39407 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39408 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39409 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39410 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39411 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39412 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39413 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39414 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39415 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39416 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39417 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39418 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39419 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39420 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39421 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39422 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39423 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39424 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39425 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39426 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39427 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39428 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39429 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39430 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39431 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39432 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39433 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39434 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39435 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39436 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39437 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39438 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39439 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39440 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39441 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39442 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39443 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39444 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39445 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39446 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39447 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39448 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39449 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39450 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39451 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39452 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39453 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39454 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39455 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39456 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39457 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39458 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39459 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39460
39461 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39462 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39463 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39464 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39465
39466 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39467 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39468 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39469 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39470 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39471 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39472 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39473 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39474 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39475 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39476 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39477 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39478 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39479 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39480 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39481 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39482 }
39483
wxWidgets (Impactor)