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


03dddfbf2721459c765f0f8b532fe265f90d4b1e
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #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_wxMetafileDataObject swig_types[93]
2560 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
2561 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
2562 #define SWIGTYPE_p_wxMouseEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseState swig_types[97]
2564 #define SWIGTYPE_p_wxMoveEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[99]
2566 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxNcPaintEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNotifyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxObject swig_types[103]
2570 #define SWIGTYPE_p_wxOutputStream swig_types[104]
2571 #define SWIGTYPE_p_wxPCXHandler swig_types[105]
2572 #define SWIGTYPE_p_wxPNGHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNMHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPaintEvent swig_types[108]
2575 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaperSize swig_types[110]
2577 #define SWIGTYPE_p_wxPoint swig_types[111]
2578 #define SWIGTYPE_p_wxPowerEvent swig_types[112]
2579 #define SWIGTYPE_p_wxProcessEvent swig_types[113]
2580 #define SWIGTYPE_p_wxPyApp swig_types[114]
2581 #define SWIGTYPE_p_wxPyArtProvider swig_types[115]
2582 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[116]
2583 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[118]
2585 #define SWIGTYPE_p_wxPyDropSource swig_types[119]
2586 #define SWIGTYPE_p_wxPyDropTarget swig_types[120]
2587 #define SWIGTYPE_p_wxPyEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[122]
2589 #define SWIGTYPE_p_wxPyImageHandler swig_types[123]
2590 #define SWIGTYPE_p_wxPyLog swig_types[124]
2591 #define SWIGTYPE_p_wxPyProcess swig_types[125]
2592 #define SWIGTYPE_p_wxPySizer swig_types[126]
2593 #define SWIGTYPE_p_wxPyTextDataObject swig_types[127]
2594 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[128]
2595 #define SWIGTYPE_p_wxPyTimer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTipProvider swig_types[130]
2597 #define SWIGTYPE_p_wxPyValidator swig_types[131]
2598 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[132]
2599 #define SWIGTYPE_p_wxRect swig_types[133]
2600 #define SWIGTYPE_p_wxScrollEvent swig_types[134]
2601 #define SWIGTYPE_p_wxScrollWinEvent swig_types[135]
2602 #define SWIGTYPE_p_wxSetCursorEvent swig_types[136]
2603 #define SWIGTYPE_p_wxShowEvent swig_types[137]
2604 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[138]
2605 #define SWIGTYPE_p_wxSize swig_types[139]
2606 #define SWIGTYPE_p_wxSizeEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSizer swig_types[141]
2608 #define SWIGTYPE_p_wxSizerItem swig_types[142]
2609 #define SWIGTYPE_p_wxSound swig_types[143]
2610 #define SWIGTYPE_p_wxStandardPaths swig_types[144]
2611 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[146]
2613 #define SWIGTYPE_p_wxStopWatch swig_types[147]
2614 #define SWIGTYPE_p_wxString swig_types[148]
2615 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[149]
2616 #define SWIGTYPE_p_wxSystemOptions swig_types[150]
2617 #define SWIGTYPE_p_wxSystemSettings swig_types[151]
2618 #define SWIGTYPE_p_wxTIFFHandler swig_types[152]
2619 #define SWIGTYPE_p_wxTextCtrl swig_types[153]
2620 #define SWIGTYPE_p_wxTextDataObject swig_types[154]
2621 #define SWIGTYPE_p_wxTimeSpan swig_types[155]
2622 #define SWIGTYPE_p_wxTimer swig_types[156]
2623 #define SWIGTYPE_p_wxTimerEvent swig_types[157]
2624 #define SWIGTYPE_p_wxTimerRunner swig_types[158]
2625 #define SWIGTYPE_p_wxTipProvider swig_types[159]
2626 #define SWIGTYPE_p_wxToolTip swig_types[160]
2627 #define SWIGTYPE_p_wxURLDataObject swig_types[161]
2628 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[162]
2629 #define SWIGTYPE_p_wxValidator swig_types[163]
2630 #define SWIGTYPE_p_wxVideoMode swig_types[164]
2631 #define SWIGTYPE_p_wxWindow swig_types[165]
2632 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[166]
2633 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[167]
2634 #define SWIGTYPE_p_wxWindowDisabler swig_types[168]
2635 #define SWIGTYPE_p_wxXPMHandler swig_types[169]
2636 static swig_type_info *swig_types[171];
2637 static swig_module_info swig_module = {swig_types, 170, 0, 0, 0, 0};
2638 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2639 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2640
2641 /* -------- TYPES TABLE (END) -------- */
2642
2643 #if (PY_VERSION_HEX <= 0x02000000)
2644 # if !defined(SWIG_PYTHON_CLASSIC)
2645 # error "This python version requires to use swig with the '-classic' option"
2646 # endif
2647 #endif
2648 #if (PY_VERSION_HEX <= 0x02020000)
2649 # error "This python version requires to use swig with the '-nomodern' option"
2650 #endif
2651 #if (PY_VERSION_HEX <= 0x02020000)
2652 # error "This python version requires to use swig with the '-nomodernargs' option"
2653 #endif
2654 #ifndef METH_O
2655 # error "This python version requires to use swig with the '-nofastunpack' option"
2656 #endif
2657
2658 /*-----------------------------------------------
2659 @(target):= _misc_.so
2660 ------------------------------------------------*/
2661 #define SWIG_init init_misc_
2662
2663 #define SWIG_name "_misc_"
2664
2665 #define SWIGVERSION 0x010329
2666
2667
2668 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2669 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2670
2671
2672 #include <stdexcept>
2673
2674
2675 namespace swig {
2676 class PyObject_ptr {
2677 protected:
2678 PyObject *_obj;
2679
2680 public:
2681 PyObject_ptr() :_obj(0)
2682 {
2683 }
2684
2685 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2686 {
2687 Py_XINCREF(_obj);
2688 }
2689
2690 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2691 {
2692 if (initial_ref) Py_XINCREF(_obj);
2693 }
2694
2695 PyObject_ptr & operator=(const PyObject_ptr& item)
2696 {
2697 Py_XINCREF(item._obj);
2698 Py_XDECREF(_obj);
2699 _obj = item._obj;
2700 return *this;
2701 }
2702
2703 ~PyObject_ptr()
2704 {
2705 Py_XDECREF(_obj);
2706 }
2707
2708 operator PyObject *() const
2709 {
2710 return _obj;
2711 }
2712
2713 PyObject *operator->() const
2714 {
2715 return _obj;
2716 }
2717 };
2718 }
2719
2720
2721 namespace swig {
2722 struct PyObject_var : PyObject_ptr {
2723 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2724
2725 PyObject_var & operator = (PyObject* obj)
2726 {
2727 Py_XDECREF(_obj);
2728 _obj = obj;
2729 return *this;
2730 }
2731 };
2732 }
2733
2734
2735 #include "wx/wxPython/wxPython.h"
2736 #include "wx/wxPython/pyclasses.h"
2737 #include "wx/wxPython/pyistream.h"
2738
2739 static const wxString wxPyEmptyString(wxEmptyString);
2740
2741
2742
2743 #define SWIG_From_long PyInt_FromLong
2744
2745
2746 SWIGINTERNINLINE PyObject *
2747 SWIG_From_int (int value)
2748 {
2749 return SWIG_From_long (value);
2750 }
2751
2752
2753 #include <limits.h>
2754 #ifndef LLONG_MIN
2755 # define LLONG_MIN LONG_LONG_MIN
2756 #endif
2757 #ifndef LLONG_MAX
2758 # define LLONG_MAX LONG_LONG_MAX
2759 #endif
2760 #ifndef ULLONG_MAX
2761 # define ULLONG_MAX ULONG_LONG_MAX
2762 #endif
2763
2764
2765 SWIGINTERN int
2766 SWIG_AsVal_long (PyObject* obj, long* val)
2767 {
2768 if (PyNumber_Check(obj)) {
2769 if (val) *val = PyInt_AsLong(obj);
2770 return SWIG_OK;
2771 }
2772 return SWIG_TypeError;
2773 }
2774
2775
2776 SWIGINTERN int
2777 SWIG_AsVal_int (PyObject * obj, int *val)
2778 {
2779 long v;
2780 int res = SWIG_AsVal_long (obj, &v);
2781 if (SWIG_IsOK(res)) {
2782 if ((v < INT_MIN || v > INT_MAX)) {
2783 return SWIG_OverflowError;
2784 } else {
2785 if (val) *val = static_cast< int >(v);
2786 }
2787 }
2788 return res;
2789 }
2790
2791 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2792
2793 #include <wx/stockitem.h>
2794
2795 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2796 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2797 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2798
2799 SWIGINTERN int
2800 SWIG_AsVal_bool (PyObject *obj, bool *val)
2801 {
2802 if (obj == Py_True) {
2803 if (val) *val = true;
2804 return SWIG_OK;
2805 } else if (obj == Py_False) {
2806 if (val) *val = false;
2807 return SWIG_OK;
2808 } else {
2809 long v = 0;
2810 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2811 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2812 return res;
2813 }
2814 }
2815
2816
2817 wxMemorySize wxGetFreeMemory()
2818 { wxPyRaiseNotImplemented(); return 0; }
2819
2820
2821 SWIGINTERN int
2822 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2823 {
2824 long v = 0;
2825 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2826 return SWIG_TypeError;
2827 }
2828 else if (val)
2829 *val = (unsigned long)v;
2830 return SWIG_OK;
2831 }
2832
2833
2834 SWIGINTERNINLINE PyObject*
2835 SWIG_From_unsigned_SS_long (unsigned long value)
2836 {
2837 return (value > LONG_MAX) ?
2838 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2839 }
2840
2841
2842 void* wxGetXDisplay()
2843 {
2844 #ifdef __WXGTK__
2845 return wxGetDisplay();
2846 #else
2847 return NULL;
2848 #endif
2849 }
2850
2851
2852 wxWindow* FindWindowAtPointer() {
2853 wxPoint unused;
2854 return wxFindWindowAtPointer(unused);
2855 }
2856
2857
2858 void wxWakeUpMainThread() {}
2859
2860
2861 bool wxThread_IsMain() {
2862 #ifdef WXP_WITH_THREAD
2863 return wxThread::IsMain();
2864 #else
2865 return true;
2866 #endif
2867 }
2868
2869 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2870 delete self;
2871 }
2872
2873 #include <wx/snglinst.h>
2874
2875
2876 #ifdef __WXMSW__
2877 #include <wx/msw/private.h>
2878 #include <wx/dynload.h>
2879 #endif
2880
2881
2882
2883 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2884 #if 0
2885 , int method
2886 #endif
2887 )
2888 {
2889 #ifdef __WXMSW__
2890 #if 0
2891 switch (method)
2892 {
2893 case 1:
2894 // This one only partially works. Appears to be an undocumented
2895 // "standard" convention that not all widgets adhear to. For
2896 // example, for some widgets backgrounds or non-client areas may
2897 // not be painted.
2898 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2899 break;
2900
2901 case 2:
2902 #endif
2903 // This one works much better, nearly all widgets and their
2904 // children are captured correctly[**]. Prior to the big
2905 // background erase changes that Vadim did in 2004-2005 this
2906 // method failed badly on XP with Themes activated, most native
2907 // widgets draw only partially, if at all. Without themes it
2908 // worked just like on Win2k. After those changes this method
2909 // works very well.
2910 //
2911 // ** For example the radio buttons in a wxRadioBox are not its
2912 // children by default, but you can capture it via the panel
2913 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2914 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2915 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2916 PRF_ERASEBKGND | PRF_OWNED );
2917 return true;
2918 #if 0
2919 break;
2920
2921 case 3:
2922 // This one is only defined in the latest SDK and is only
2923 // available on XP. MSDN says it is similar to sending WM_PRINT
2924 // so I expect that it will work similar to the above. Since it
2925 // is avaialble only on XP, it can't be compiled like this and
2926 // will have to be loaded dynamically.
2927 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2928
2929 // fall through
2930
2931 case 4:
2932 // Use PrintWindow if available, or fallback to WM_PRINT
2933 // otherwise. Unfortunately using PrintWindow is even worse than
2934 // WM_PRINT. For most native widgets nothing is drawn to the dc
2935 // at all, with or without Themes.
2936 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2937 static bool s_triedToLoad = false;
2938 static PrintWindow_t pfnPrintWindow = NULL;
2939 if ( !s_triedToLoad )
2940 {
2941
2942 s_triedToLoad = true;
2943 wxDynamicLibrary dllUser32(_T("user32.dll"));
2944 if ( dllUser32.IsLoaded() )
2945 {
2946 wxLogNull nolog; // Don't report errors here
2947 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2948 }
2949 }
2950 if (pfnPrintWindow)
2951 {
2952 //printf("Using PrintWindow\n");
2953 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2954 }
2955 else
2956 {
2957 //printf("Using WM_PRINT\n");
2958 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2959 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2960 PRF_ERASEBKGND | PRF_OWNED );
2961 }
2962 }
2963 #endif // 0
2964 #else
2965 return false;
2966 #endif // __WXMSW__
2967 }
2968
2969
2970
2971 #include <wx/tipdlg.h>
2972
2973
2974 SWIGINTERNINLINE PyObject *
2975 SWIG_From_size_t (size_t value)
2976 {
2977 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2978 }
2979
2980
2981 class wxPyTipProvider : public wxTipProvider {
2982 public:
2983 wxPyTipProvider(size_t currentTip)
2984 : wxTipProvider(currentTip) {}
2985
2986 DEC_PYCALLBACK_STRING__pure(GetTip);
2987 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2988 PYPRIVATE;
2989 };
2990
2991 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2992 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2993
2994
2995 SWIGINTERNINLINE int
2996 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2997 {
2998 unsigned long v;
2999 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3000 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3001 return res;
3002 }
3003
3004
3005 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3006
3007 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3008
3009 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3010 : wxTimer(owner, id)
3011 {
3012 if (owner == NULL)
3013 SetOwner(this);
3014 }
3015
3016
3017 SWIGINTERN swig_type_info*
3018 SWIG_pchar_descriptor()
3019 {
3020 static int init = 0;
3021 static swig_type_info* info = 0;
3022 if (!init) {
3023 info = SWIG_TypeQuery("_p_char");
3024 init = 1;
3025 }
3026 return info;
3027 }
3028
3029
3030 SWIGINTERNINLINE PyObject *
3031 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3032 {
3033 if (carray) {
3034 if (size > INT_MAX) {
3035 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3036 return pchar_descriptor ?
3037 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3038 } else {
3039 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3040 }
3041 } else {
3042 return SWIG_Py_Void();
3043 }
3044 }
3045
3046
3047 SWIGINTERNINLINE PyObject *
3048 SWIG_FromCharPtr(const char *cptr)
3049 {
3050 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3051 }
3052
3053
3054 SWIGINTERN int
3055 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3056 {
3057 unsigned long v;
3058 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3059 if (SWIG_IsOK(res)) {
3060 if ((v > UINT_MAX)) {
3061 return SWIG_OverflowError;
3062 } else {
3063 if (val) *val = static_cast< unsigned int >(v);
3064 }
3065 }
3066 return res;
3067 }
3068
3069 SWIGINTERN wxString wxLog_TimeStamp(){
3070 wxString msg;
3071 wxLog::TimeStamp(&msg);
3072 return msg;
3073 }
3074 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3075 // Make some wrappers that double any % signs so they are 'escaped'
3076 void wxPyLogFatalError(const wxString& msg)
3077 {
3078 wxString m(msg);
3079 m.Replace(wxT("%"), wxT("%%"));
3080 wxLogFatalError(m);
3081 }
3082
3083 void wxPyLogError(const wxString& msg)
3084 {
3085 wxString m(msg);
3086 m.Replace(wxT("%"), wxT("%%"));
3087 wxLogError(m);
3088 }
3089
3090 void wxPyLogWarning(const wxString& msg)
3091 {
3092 wxString m(msg);
3093 m.Replace(wxT("%"), wxT("%%"));
3094 wxLogWarning(m);
3095 }
3096
3097 void wxPyLogMessage(const wxString& msg)
3098 {
3099 wxString m(msg);
3100 m.Replace(wxT("%"), wxT("%%"));
3101 wxLogMessage(m);
3102 }
3103
3104 void wxPyLogInfo(const wxString& msg)
3105 {
3106 wxString m(msg);
3107 m.Replace(wxT("%"), wxT("%%"));
3108 wxLogInfo(m);
3109 }
3110
3111 void wxPyLogDebug(const wxString& msg)
3112 {
3113 wxString m(msg);
3114 m.Replace(wxT("%"), wxT("%%"));
3115 wxLogDebug(m);
3116 }
3117
3118 void wxPyLogVerbose(const wxString& msg)
3119 {
3120 wxString m(msg);
3121 m.Replace(wxT("%"), wxT("%%"));
3122 wxLogVerbose(m);
3123 }
3124
3125 void wxPyLogStatus(const wxString& msg)
3126 {
3127 wxString m(msg);
3128 m.Replace(wxT("%"), wxT("%%"));
3129 wxLogStatus(m);
3130 }
3131
3132 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3133 {
3134 wxString m(msg);
3135 m.Replace(wxT("%"), wxT("%%"));
3136 wxLogStatus(pFrame, m);
3137 }
3138
3139 void wxPyLogSysError(const wxString& msg)
3140 {
3141 wxString m(msg);
3142 m.Replace(wxT("%"), wxT("%%"));
3143 wxLogSysError(m);
3144 }
3145
3146 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3147 {
3148 wxString m(msg);
3149 m.Replace(wxT("%"), wxT("%%"));
3150 wxLogGeneric(level, m);
3151 }
3152
3153 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3154 {
3155 wxString m(msg);
3156 m.Replace(wxT("%"), wxT("%%"));
3157 wxLogTrace(mask, m);
3158 }
3159
3160 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3161 {
3162 wxString m(msg);
3163 m.Replace(wxT("%"), wxT("%%"));
3164 wxLogTrace(mask, m);
3165 }
3166
3167
3168
3169 // A wxLog class that can be derived from in wxPython
3170 class wxPyLog : public wxLog {
3171 public:
3172 wxPyLog() : wxLog() {}
3173
3174 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3175 bool found;
3176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3177 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3178 PyObject* s = wx2PyString(szString);
3179 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3180 Py_DECREF(s);
3181 }
3182 wxPyEndBlockThreads(blocked);
3183 if (! found)
3184 wxLog::DoLog(level, szString, t);
3185 }
3186
3187 virtual void DoLogString(const wxChar *szString, time_t t) {
3188 bool found;
3189 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3190 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3191 PyObject* s = wx2PyString(szString);
3192 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3193 Py_DECREF(s);
3194 }
3195 wxPyEndBlockThreads(blocked);
3196 if (! found)
3197 wxLog::DoLogString(szString, t);
3198 }
3199
3200 DEC_PYCALLBACK_VOID_(Flush);
3201 PYPRIVATE;
3202 };
3203 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3204
3205
3206
3207
3208 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3209
3210
3211 #include <wx/joystick.h>
3212
3213
3214 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3215 // A C++ stub class for wxJoystick for platforms that don't have it.
3216 class wxJoystick : public wxObject {
3217 public:
3218 wxJoystick(int joystick = wxJOYSTICK1) {
3219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3220 PyErr_SetString(PyExc_NotImplementedError,
3221 "wxJoystick is not available on this platform.");
3222 wxPyEndBlockThreads(blocked);
3223 }
3224 wxPoint GetPosition() { return wxPoint(-1,-1); }
3225 int GetZPosition() { return -1; }
3226 int GetButtonState() { return -1; }
3227 int GetPOVPosition() { return -1; }
3228 int GetPOVCTSPosition() { return -1; }
3229 int GetRudderPosition() { return -1; }
3230 int GetUPosition() { return -1; }
3231 int GetVPosition() { return -1; }
3232 int GetMovementThreshold() { return -1; }
3233 void SetMovementThreshold(int threshold) {}
3234
3235 bool IsOk(void) { return false; }
3236 int GetNumberJoysticks() { return -1; }
3237 int GetManufacturerId() { return -1; }
3238 int GetProductId() { return -1; }
3239 wxString GetProductName() { return wxEmptyString; }
3240 int GetXMin() { return -1; }
3241 int GetYMin() { return -1; }
3242 int GetZMin() { return -1; }
3243 int GetXMax() { return -1; }
3244 int GetYMax() { return -1; }
3245 int GetZMax() { return -1; }
3246 int GetNumberButtons() { return -1; }
3247 int GetNumberAxes() { return -1; }
3248 int GetMaxButtons() { return -1; }
3249 int GetMaxAxes() { return -1; }
3250 int GetPollingMin() { return -1; }
3251 int GetPollingMax() { return -1; }
3252 int GetRudderMin() { return -1; }
3253 int GetRudderMax() { return -1; }
3254 int GetUMin() { return -1; }
3255 int GetUMax() { return -1; }
3256 int GetVMin() { return -1; }
3257 int GetVMax() { return -1; }
3258
3259 bool HasRudder() { return false; }
3260 bool HasZ() { return false; }
3261 bool HasU() { return false; }
3262 bool HasV() { return false; }
3263 bool HasPOV() { return false; }
3264 bool HasPOV4Dir() { return false; }
3265 bool HasPOVCTS() { return false; }
3266
3267 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3268 bool ReleaseCapture() { return false; }
3269 };
3270 #endif
3271
3272
3273 #include <wx/sound.h>
3274
3275
3276 #if !wxUSE_SOUND
3277 // A C++ stub class for wxWave for platforms that don't have it.
3278 class wxSound : public wxObject
3279 {
3280 public:
3281 wxSound() {
3282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3283 PyErr_SetString(PyExc_NotImplementedError,
3284 "wxSound is not available on this platform.");
3285 wxPyEndBlockThreads(blocked);
3286 }
3287 wxSound(const wxString&/*, bool*/) {
3288 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3289 PyErr_SetString(PyExc_NotImplementedError,
3290 "wxSound is not available on this platform.");
3291 wxPyEndBlockThreads(blocked);
3292 }
3293 wxSound(int, const wxByte*) {
3294 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3295 PyErr_SetString(PyExc_NotImplementedError,
3296 "wxSound is not available on this platform.");
3297 wxPyEndBlockThreads(blocked);
3298 }
3299
3300 ~wxSound() {};
3301
3302 bool Create(const wxString&/*, bool*/) { return false; }
3303 bool Create(int, const wxByte*) { return false; };
3304 bool IsOk() { return false; };
3305 bool Play(unsigned) const { return false; }
3306 static bool Play(const wxString&, unsigned) { return false; }
3307 static void Stop() {}
3308 };
3309
3310 #endif
3311
3312 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3313 if (fileName.Length() == 0)
3314 return new wxSound;
3315 else
3316 return new wxSound(fileName);
3317 }
3318 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3319 unsigned char* buffer; int size;
3320 wxSound *sound = NULL;
3321
3322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3323 if (!PyArg_Parse(data, "t#", &buffer, &size))
3324 goto done;
3325 sound = new wxSound(size, buffer);
3326 done:
3327 wxPyEndBlockThreads(blocked);
3328 return sound;
3329 }
3330 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3331 #ifndef __WXMAC__
3332 unsigned char* buffer;
3333 int size;
3334 bool rv = false;
3335
3336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3337 if (!PyArg_Parse(data, "t#", &buffer, &size))
3338 goto done;
3339 rv = self->Create(size, buffer);
3340 done:
3341 wxPyEndBlockThreads(blocked);
3342 return rv;
3343 #else
3344 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3345 PyErr_SetString(PyExc_NotImplementedError,
3346 "Create from data is not available on this platform.");
3347 wxPyEndBlockThreads(blocked);
3348 return false;
3349 #endif
3350 }
3351
3352 #include <wx/mimetype.h>
3353
3354 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3355 wxString str;
3356 if (self->GetMimeType(&str))
3357 return wx2PyString(str);
3358 else
3359 RETURN_NONE();
3360 }
3361 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3362 wxArrayString arr;
3363 if (self->GetMimeTypes(arr))
3364 return wxArrayString2PyList_helper(arr);
3365 else
3366 RETURN_NONE();
3367 }
3368 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3369 wxArrayString arr;
3370 if (self->GetExtensions(arr))
3371 return wxArrayString2PyList_helper(arr);
3372 else
3373 RETURN_NONE();
3374 }
3375 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3376 wxIconLocation loc;
3377 if (self->GetIcon(&loc))
3378 return new wxIcon(loc);
3379 else
3380 return NULL;
3381 }
3382 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3383 wxIconLocation loc;
3384 if (self->GetIcon(&loc)) {
3385 wxString iconFile = loc.GetFileName();
3386 int iconIndex = -1;
3387
3388
3389
3390 // Make a tuple and put the values in it
3391 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3392 PyObject* tuple = PyTuple_New(3);
3393 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3394 wxT("wxIcon"), true));
3395 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3396 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3397 wxPyEndBlockThreads(blocked);
3398 return tuple;
3399 }
3400 else
3401 RETURN_NONE();
3402 }
3403 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3404 wxString str;
3405 if (self->GetDescription(&str))
3406 return wx2PyString(str);
3407 else
3408 RETURN_NONE();
3409 }
3410 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3411 wxString str;
3412 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3413 return wx2PyString(str);
3414 else
3415 RETURN_NONE();
3416 }
3417 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3418 wxString str;
3419 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3420 return wx2PyString(str);
3421 else
3422 RETURN_NONE();
3423 }
3424 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3425 wxArrayString verbs;
3426 wxArrayString commands;
3427 if (self->GetAllCommands(&verbs, &commands,
3428 wxFileType::MessageParameters(filename, mimetype))) {
3429 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3430 PyObject* tuple = PyTuple_New(2);
3431 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3432 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3433 wxPyEndBlockThreads(blocked);
3434 return tuple;
3435 }
3436 else
3437 RETURN_NONE();
3438 }
3439 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3440 return wxFileType::ExpandCommand(command,
3441 wxFileType::MessageParameters(filename, mimetype));
3442 }
3443 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3444 wxArrayString arr;
3445 self->EnumAllFileTypes(arr);
3446 return wxArrayString2PyList_helper(arr);
3447 }
3448
3449 #include <wx/artprov.h>
3450
3451 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3452 static const wxString wxPyART_MENU(wxART_MENU);
3453 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3454 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3455 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3456 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3457 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3458 static const wxString wxPyART_OTHER(wxART_OTHER);
3459 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3460 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3461 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3462 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3463 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3464 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3465 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3466 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3467 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3468 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3469 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3470 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3471 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3472 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3473 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3474 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3475 static const wxString wxPyART_PRINT(wxART_PRINT);
3476 static const wxString wxPyART_HELP(wxART_HELP);
3477 static const wxString wxPyART_TIP(wxART_TIP);
3478 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3479 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3480 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3481 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3482 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3483 static const wxString wxPyART_CDROM(wxART_CDROM);
3484 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3485 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3486 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3487 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3488 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3489 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3490 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3491 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3492 static const wxString wxPyART_ERROR(wxART_ERROR);
3493 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3494 static const wxString wxPyART_WARNING(wxART_WARNING);
3495 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3496 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3497 static const wxString wxPyART_COPY(wxART_COPY);
3498 static const wxString wxPyART_CUT(wxART_CUT);
3499 static const wxString wxPyART_PASTE(wxART_PASTE);
3500 static const wxString wxPyART_DELETE(wxART_DELETE);
3501 static const wxString wxPyART_NEW(wxART_NEW);
3502 static const wxString wxPyART_UNDO(wxART_UNDO);
3503 static const wxString wxPyART_REDO(wxART_REDO);
3504 static const wxString wxPyART_QUIT(wxART_QUIT);
3505 static const wxString wxPyART_FIND(wxART_FIND);
3506 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3507 // Python aware wxArtProvider
3508 class wxPyArtProvider : public wxArtProvider {
3509 public:
3510
3511 virtual wxBitmap CreateBitmap(const wxArtID& id,
3512 const wxArtClient& client,
3513 const wxSize& size) {
3514 wxBitmap rval = wxNullBitmap;
3515 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3516 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3517 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3518 PyObject* ro;
3519 wxBitmap* ptr;
3520 PyObject* s1, *s2;
3521 s1 = wx2PyString(id);
3522 s2 = wx2PyString(client);
3523 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3524 Py_DECREF(so);
3525 Py_DECREF(s1);
3526 Py_DECREF(s2);
3527 if (ro) {
3528 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3529 rval = *ptr;
3530 Py_DECREF(ro);
3531 }
3532 }
3533 wxPyEndBlockThreads(blocked);
3534 return rval;
3535 }
3536
3537 PYPRIVATE;
3538 };
3539
3540 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3541
3542
3543
3544 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3545 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3546 PyObject* ret = PyTuple_New(3);
3547 if (ret) {
3548 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3549 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3550 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3551 }
3552 wxPyEndBlockThreads(blocked);
3553 return ret;
3554 }
3555
3556 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3557 bool cont;
3558 long index = 0;
3559 wxString value;
3560
3561 cont = self->GetFirstGroup(value, index);
3562 return __EnumerationHelper(cont, value, index);
3563 }
3564 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3565 bool cont;
3566 wxString value;
3567
3568 cont = self->GetNextGroup(value, index);
3569 return __EnumerationHelper(cont, value, index);
3570 }
3571 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3572 bool cont;
3573 long index = 0;
3574 wxString value;
3575
3576 cont = self->GetFirstEntry(value, index);
3577 return __EnumerationHelper(cont, value, index);
3578 }
3579 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3580 bool cont;
3581 wxString value;
3582
3583 cont = self->GetNextEntry(value, index);
3584 return __EnumerationHelper(cont, value, index);
3585 }
3586 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3587 long rv;
3588 self->Read(key, &rv, defaultVal);
3589 return rv;
3590 }
3591
3592 SWIGINTERN int
3593 SWIG_AsVal_double (PyObject *obj, double* val)
3594 {
3595 if (PyNumber_Check(obj)) {
3596 if (val) *val = PyFloat_AsDouble(obj);
3597 return SWIG_OK;
3598 }
3599 return SWIG_TypeError;
3600 }
3601
3602 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3603 double rv;
3604 self->Read(key, &rv, defaultVal);
3605 return rv;
3606 }
3607
3608 #define SWIG_From_double PyFloat_FromDouble
3609
3610 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3611 bool rv;
3612 self->Read(key, &rv, defaultVal);
3613 return rv;
3614 }
3615
3616 #include <wx/datetime.h>
3617
3618 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3619 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3620
3621 #define LOCAL_TZ wxDateTime::Local
3622
3623 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3624 wxString am;
3625 wxString pm;
3626 wxDateTime::GetAmPmStrings(&am, &pm);
3627 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3628 PyObject* tup = PyTuple_New(2);
3629 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3630 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3631 wxPyEndBlockThreads(blocked);
3632 return tup;
3633 }
3634
3635 SWIGINTERNINLINE PyObject *
3636 SWIG_From_unsigned_SS_int (unsigned int value)
3637 {
3638 return SWIG_From_unsigned_SS_long (value);
3639 }
3640
3641 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3642 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3643 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3644 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3645 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3646 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3647 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3648 return (*self < *other);
3649 }
3650 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3652 return (*self <= *other);
3653 }
3654 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3656 return (*self > *other);
3657 }
3658 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3660 return (*self >= *other);
3661 }
3662 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3664 return (*self == *other);
3665 }
3666 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3667 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3668 return (*self != *other);
3669 }
3670 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3671 const wxChar* rv;
3672 const wxChar* _date = date;
3673 rv = self->ParseRfc822Date(_date);
3674 if (rv == NULL) return -1;
3675 return rv - _date;
3676 }
3677 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3678 const wxChar* rv;
3679 const wxChar* _date = date;
3680 rv = self->ParseFormat(_date, format, dateDef);
3681 if (rv == NULL) return -1;
3682 return rv - _date;
3683 }
3684 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3685 const wxChar* rv;
3686 const wxChar* _datetime = datetime;
3687 rv = self->ParseDateTime(_datetime);
3688 if (rv == NULL) return -1;
3689 return rv - _datetime;
3690 }
3691 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3692 const wxChar* rv;
3693 const wxChar* _date = date;
3694 rv = self->ParseDate(_date);
3695 if (rv == NULL) return -1;
3696 return rv - _date;
3697 }
3698 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3699 const wxChar* rv;
3700 const wxChar* _time = time;
3701 rv = self->ParseTime(_time);
3702 if (rv == NULL) return -1;
3703 return rv - _time;
3704 }
3705 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3706 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3707 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3709 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3710 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3712 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3713 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3714 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3715 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3716 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3717 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3718 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3719 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3720 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3721
3722 #include <wx/dataobj.h>
3723
3724 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3725 size_t count = self->GetFormatCount(dir);
3726 wxDataFormat* formats = new wxDataFormat[count];
3727 self->GetAllFormats(formats, dir);
3728
3729 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3730 PyObject* list = PyList_New(count);
3731 for (size_t i=0; i<count; i++) {
3732 wxDataFormat* format = new wxDataFormat(formats[i]);
3733 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3734 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3735 }
3736 wxPyEndBlockThreads(blocked);
3737 delete [] formats;
3738 return list;
3739 }
3740 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3741 PyObject* rval = NULL;
3742 size_t size = self->GetDataSize(format);
3743 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3744 if (size) {
3745 char* buf = new char[size];
3746 if (self->GetDataHere(format, buf))
3747 rval = PyString_FromStringAndSize(buf, size);
3748 delete [] buf;
3749 }
3750 if (! rval) {
3751 rval = Py_None;
3752 Py_INCREF(rval);
3753 }
3754 wxPyEndBlockThreads(blocked);
3755 return rval;
3756 }
3757 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3758 bool rval;
3759 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3760 if (PyString_Check(data)) {
3761 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3762 }
3763 else {
3764 // raise a TypeError if not a string
3765 PyErr_SetString(PyExc_TypeError, "String expected.");
3766 rval = false;
3767 }
3768 wxPyEndBlockThreads(blocked);
3769 return rval;
3770 }
3771 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3772 PyObject* rval = NULL;
3773 size_t size = self->GetDataSize();
3774 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3775 if (size) {
3776 char* buf = new char[size];
3777 if (self->GetDataHere(buf))
3778 rval = PyString_FromStringAndSize(buf, size);
3779 delete [] buf;
3780 }
3781 if (! rval) {
3782 rval = Py_None;
3783 Py_INCREF(rval);
3784 }
3785 wxPyEndBlockThreads(blocked);
3786 return rval;
3787 }
3788 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3789 bool rval;
3790 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3791 if (PyString_Check(data)) {
3792 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3793 }
3794 else {
3795 // raise a TypeError if not a string
3796 PyErr_SetString(PyExc_TypeError, "String expected.");
3797 rval = false;
3798 }
3799 wxPyEndBlockThreads(blocked);
3800 return rval;
3801 }
3802 // Create a new class for wxPython to use
3803 class wxPyDataObjectSimple : public wxDataObjectSimple {
3804 public:
3805 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3806 : wxDataObjectSimple(format) {}
3807
3808 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3809 bool GetDataHere(void *buf) const;
3810 bool SetData(size_t len, const void *buf);
3811 PYPRIVATE;
3812 };
3813
3814 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3815
3816 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3817 // We need to get the data for this object and write it to buf. I think
3818 // the best way to do this for wxPython is to have the Python method
3819 // return either a string or None and then act appropriately with the
3820 // C++ version.
3821
3822 bool rval = false;
3823 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3824 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3825 PyObject* ro;
3826 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3827 if (ro) {
3828 rval = (ro != Py_None && PyString_Check(ro));
3829 if (rval)
3830 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3831 Py_DECREF(ro);
3832 }
3833 }
3834 wxPyEndBlockThreads(blocked);
3835 return rval;
3836 }
3837
3838 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3839 // For this one we simply need to make a string from buf and len
3840 // and send it to the Python method.
3841 bool rval = false;
3842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3843 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3844 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3845 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3846 Py_DECREF(data);
3847 }
3848 wxPyEndBlockThreads(blocked);
3849 return rval;
3850 }
3851
3852 // Create a new class for wxPython to use
3853 class wxPyTextDataObject : public wxTextDataObject {
3854 public:
3855 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3856 : wxTextDataObject(text) {}
3857
3858 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3859 DEC_PYCALLBACK_STRING__const(GetText);
3860 DEC_PYCALLBACK__STRING(SetText);
3861 PYPRIVATE;
3862 };
3863
3864 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3865 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3866 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3867
3868
3869 // Create a new class for wxPython to use
3870 class wxPyBitmapDataObject : public wxBitmapDataObject {
3871 public:
3872 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3873 : wxBitmapDataObject(bitmap) {}
3874
3875 wxBitmap GetBitmap() const;
3876 void SetBitmap(const wxBitmap& bitmap);
3877 PYPRIVATE;
3878 };
3879
3880 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3881 wxBitmap* rval = &wxNullBitmap;
3882 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3883 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3884 PyObject* ro;
3885 wxBitmap* ptr;
3886 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3887 if (ro) {
3888 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3889 rval = ptr;
3890 Py_DECREF(ro);
3891 }
3892 }
3893 wxPyEndBlockThreads(blocked);
3894 return *rval;
3895 }
3896
3897 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3898 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3899 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3900 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3901 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3902 Py_DECREF(bo);
3903 }
3904 wxPyEndBlockThreads(blocked);
3905 }
3906
3907 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3908 return new wxCustomDataObject(wxDataFormat(formatName));
3909 }
3910 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3911 bool rval;
3912 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3913 if (PyString_Check(data)) {
3914 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3915 }
3916 else {
3917 // raise a TypeError if not a string
3918 PyErr_SetString(PyExc_TypeError, "String expected.");
3919 rval = false;
3920 }
3921 wxPyEndBlockThreads(blocked);
3922 return rval;
3923 }
3924 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3925 PyObject* obj;
3926 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3927 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3928 wxPyEndBlockThreads(blocked);
3929 return obj;
3930 }
3931
3932 class wxMetafileDataObject : public wxDataObjectSimple
3933 {
3934 public:
3935 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3936 };
3937
3938
3939 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3940
3941
3942 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3943 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3945 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3946 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3947
3948
3949 class wxPyTextDropTarget : public wxTextDropTarget {
3950 public:
3951 wxPyTextDropTarget() {}
3952
3953 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3954
3955 DEC_PYCALLBACK__(OnLeave);
3956 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3959 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3960
3961 PYPRIVATE;
3962 };
3963
3964 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3965 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3966 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3969 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3970
3971
3972
3973 class wxPyFileDropTarget : public wxFileDropTarget {
3974 public:
3975 wxPyFileDropTarget() {}
3976
3977 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3978
3979 DEC_PYCALLBACK__(OnLeave);
3980 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3983 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3984
3985 PYPRIVATE;
3986 };
3987
3988 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3989 const wxArrayString& filenames) {
3990 bool rval = false;
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3993 PyObject* list = wxArrayString2PyList_helper(filenames);
3994 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3995 Py_DECREF(list);
3996 }
3997 wxPyEndBlockThreads(blocked);
3998 return rval;
3999 }
4000
4001
4002
4003 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4004 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4007 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4008
4009
4010
4011
4012 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4013
4014 #include <wx/display.h>
4015
4016 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4017 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4018
4019 #if !wxUSE_DISPLAY
4020 const wxVideoMode wxDefaultVideoMode;
4021 #endif
4022
4023 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4024 #if wxUSE_DISPLAY
4025 PyObject* pyList = NULL;
4026 wxArrayVideoModes arr = self->GetModes(mode);
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 pyList = PyList_New(0);
4029 for (size_t i=0; i < arr.GetCount(); i++)
4030 {
4031 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4032 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4033 PyList_Append(pyList, pyObj);
4034 Py_DECREF(pyObj);
4035 }
4036 wxPyEndBlockThreads(blocked);
4037 return pyList;
4038 #else
4039 wxPyRaiseNotImplemented();
4040 return NULL;
4041 #endif
4042 }
4043 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4044 #if wxUSE_DISPLAY
4045 return self->GetCurrentMode();
4046 #else
4047 wxPyRaiseNotImplemented();
4048 return wxDefaultVideoMode;
4049 #endif
4050 }
4051 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4052 #if wxUSE_DISPLAY
4053 return self->ChangeMode(mode);
4054 #else
4055 wxPyRaiseNotImplemented();
4056 return false;
4057 #endif
4058 }
4059 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4060 #if wxUSE_DISPLAY
4061 self->ResetMode();
4062 #else
4063 wxPyRaiseNotImplemented();
4064 #endif
4065 }
4066
4067 #include <wx/stdpaths.h>
4068
4069 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4070 return (wxStandardPaths*) &wxStandardPaths::Get();
4071 }
4072
4073 #ifndef wxHAS_POWER_EVENTS
4074 // Dummy class and other definitions for platforms that don't have them
4075
4076 // See wxPython_int.h for wxPowerEvent
4077
4078 enum {
4079 wxEVT_POWER_SUSPENDING,
4080 wxEVT_POWER_SUSPENDED,
4081 wxEVT_POWER_SUSPEND_CANCEL,
4082 wxEVT_POWER_RESUME,
4083 };
4084
4085 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4086 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4087
4088 #endif
4089
4090 #ifdef __cplusplus
4091 extern "C" {
4092 #endif
4093 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj = 0;
4095 wxSystemColour arg1 ;
4096 wxColour result;
4097 int val1 ;
4098 int ecode1 = 0 ;
4099 PyObject * obj0 = 0 ;
4100 char * kwnames[] = {
4101 (char *) "index", NULL
4102 };
4103
4104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4105 ecode1 = SWIG_AsVal_int(obj0, &val1);
4106 if (!SWIG_IsOK(ecode1)) {
4107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4108 }
4109 arg1 = static_cast< wxSystemColour >(val1);
4110 {
4111 if (!wxPyCheckForApp()) SWIG_fail;
4112 PyThreadState* __tstate = wxPyBeginAllowThreads();
4113 result = wxSystemSettings::GetColour(arg1);
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj = 0;
4126 wxSystemFont arg1 ;
4127 wxFont result;
4128 int val1 ;
4129 int ecode1 = 0 ;
4130 PyObject * obj0 = 0 ;
4131 char * kwnames[] = {
4132 (char *) "index", NULL
4133 };
4134
4135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4136 ecode1 = SWIG_AsVal_int(obj0, &val1);
4137 if (!SWIG_IsOK(ecode1)) {
4138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4139 }
4140 arg1 = static_cast< wxSystemFont >(val1);
4141 {
4142 if (!wxPyCheckForApp()) SWIG_fail;
4143 PyThreadState* __tstate = wxPyBeginAllowThreads();
4144 result = wxSystemSettings::GetFont(arg1);
4145 wxPyEndAllowThreads(__tstate);
4146 if (PyErr_Occurred()) SWIG_fail;
4147 }
4148 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4149 return resultobj;
4150 fail:
4151 return NULL;
4152 }
4153
4154
4155 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4156 PyObject *resultobj = 0;
4157 wxSystemMetric arg1 ;
4158 wxWindow *arg2 = (wxWindow *) NULL ;
4159 int result;
4160 int val1 ;
4161 int ecode1 = 0 ;
4162 void *argp2 = 0 ;
4163 int res2 = 0 ;
4164 PyObject * obj0 = 0 ;
4165 PyObject * obj1 = 0 ;
4166 char * kwnames[] = {
4167 (char *) "index",(char *) "win", NULL
4168 };
4169
4170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4171 ecode1 = SWIG_AsVal_int(obj0, &val1);
4172 if (!SWIG_IsOK(ecode1)) {
4173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4174 }
4175 arg1 = static_cast< wxSystemMetric >(val1);
4176 if (obj1) {
4177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4178 if (!SWIG_IsOK(res2)) {
4179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4180 }
4181 arg2 = reinterpret_cast< wxWindow * >(argp2);
4182 }
4183 {
4184 if (!wxPyCheckForApp()) SWIG_fail;
4185 PyThreadState* __tstate = wxPyBeginAllowThreads();
4186 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4187 wxPyEndAllowThreads(__tstate);
4188 if (PyErr_Occurred()) SWIG_fail;
4189 }
4190 resultobj = SWIG_From_int(static_cast< int >(result));
4191 return resultobj;
4192 fail:
4193 return NULL;
4194 }
4195
4196
4197 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4198 PyObject *resultobj = 0;
4199 wxSystemFeature arg1 ;
4200 bool result;
4201 int val1 ;
4202 int ecode1 = 0 ;
4203 PyObject * obj0 = 0 ;
4204 char * kwnames[] = {
4205 (char *) "index", NULL
4206 };
4207
4208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4209 ecode1 = SWIG_AsVal_int(obj0, &val1);
4210 if (!SWIG_IsOK(ecode1)) {
4211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4212 }
4213 arg1 = static_cast< wxSystemFeature >(val1);
4214 {
4215 if (!wxPyCheckForApp()) SWIG_fail;
4216 PyThreadState* __tstate = wxPyBeginAllowThreads();
4217 result = (bool)wxSystemSettings::HasFeature(arg1);
4218 wxPyEndAllowThreads(__tstate);
4219 if (PyErr_Occurred()) SWIG_fail;
4220 }
4221 {
4222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4223 }
4224 return resultobj;
4225 fail:
4226 return NULL;
4227 }
4228
4229
4230 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4231 PyObject *resultobj = 0;
4232 wxSystemScreenType result;
4233
4234 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4235 {
4236 if (!wxPyCheckForApp()) SWIG_fail;
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4239 wxPyEndAllowThreads(__tstate);
4240 if (PyErr_Occurred()) SWIG_fail;
4241 }
4242 resultobj = SWIG_From_int(static_cast< int >(result));
4243 return resultobj;
4244 fail:
4245 return NULL;
4246 }
4247
4248
4249 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4250 PyObject *resultobj = 0;
4251 wxSystemScreenType arg1 ;
4252 int val1 ;
4253 int ecode1 = 0 ;
4254 PyObject * obj0 = 0 ;
4255 char * kwnames[] = {
4256 (char *) "screen", NULL
4257 };
4258
4259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4260 ecode1 = SWIG_AsVal_int(obj0, &val1);
4261 if (!SWIG_IsOK(ecode1)) {
4262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4263 }
4264 arg1 = static_cast< wxSystemScreenType >(val1);
4265 {
4266 if (!wxPyCheckForApp()) SWIG_fail;
4267 PyThreadState* __tstate = wxPyBeginAllowThreads();
4268 wxSystemSettings::SetScreenType(arg1);
4269 wxPyEndAllowThreads(__tstate);
4270 if (PyErr_Occurred()) SWIG_fail;
4271 }
4272 resultobj = SWIG_Py_Void();
4273 return resultobj;
4274 fail:
4275 return NULL;
4276 }
4277
4278
4279 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4280 PyObject *obj;
4281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4282 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4283 return SWIG_Py_Void();
4284 }
4285
4286 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4287 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4288 return 1;
4289 }
4290
4291
4292 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4293 PyObject *pyobj = 0;
4294
4295 {
4296 #if wxUSE_UNICODE
4297 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4298 #else
4299 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4300 #endif
4301 }
4302 return pyobj;
4303 }
4304
4305
4306 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4307 PyObject *resultobj = 0;
4308 wxSystemOptions *result = 0 ;
4309
4310 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 result = (wxSystemOptions *)new wxSystemOptions();
4314 wxPyEndAllowThreads(__tstate);
4315 if (PyErr_Occurred()) SWIG_fail;
4316 }
4317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
4324 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4325 PyObject *resultobj = 0;
4326 wxString *arg1 = 0 ;
4327 wxString *arg2 = 0 ;
4328 bool temp1 = false ;
4329 bool temp2 = false ;
4330 PyObject * obj0 = 0 ;
4331 PyObject * obj1 = 0 ;
4332 char * kwnames[] = {
4333 (char *) "name",(char *) "value", NULL
4334 };
4335
4336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4337 {
4338 arg1 = wxString_in_helper(obj0);
4339 if (arg1 == NULL) SWIG_fail;
4340 temp1 = true;
4341 }
4342 {
4343 arg2 = wxString_in_helper(obj1);
4344 if (arg2 == NULL) SWIG_fail;
4345 temp2 = true;
4346 }
4347 {
4348 PyThreadState* __tstate = wxPyBeginAllowThreads();
4349 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4350 wxPyEndAllowThreads(__tstate);
4351 if (PyErr_Occurred()) SWIG_fail;
4352 }
4353 resultobj = SWIG_Py_Void();
4354 {
4355 if (temp1)
4356 delete arg1;
4357 }
4358 {
4359 if (temp2)
4360 delete arg2;
4361 }
4362 return resultobj;
4363 fail:
4364 {
4365 if (temp1)
4366 delete arg1;
4367 }
4368 {
4369 if (temp2)
4370 delete arg2;
4371 }
4372 return NULL;
4373 }
4374
4375
4376 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj = 0;
4378 wxString *arg1 = 0 ;
4379 int arg2 ;
4380 bool temp1 = false ;
4381 int val2 ;
4382 int ecode2 = 0 ;
4383 PyObject * obj0 = 0 ;
4384 PyObject * obj1 = 0 ;
4385 char * kwnames[] = {
4386 (char *) "name",(char *) "value", NULL
4387 };
4388
4389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4390 {
4391 arg1 = wxString_in_helper(obj0);
4392 if (arg1 == NULL) SWIG_fail;
4393 temp1 = true;
4394 }
4395 ecode2 = SWIG_AsVal_int(obj1, &val2);
4396 if (!SWIG_IsOK(ecode2)) {
4397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4398 }
4399 arg2 = static_cast< int >(val2);
4400 {
4401 PyThreadState* __tstate = wxPyBeginAllowThreads();
4402 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4403 wxPyEndAllowThreads(__tstate);
4404 if (PyErr_Occurred()) SWIG_fail;
4405 }
4406 resultobj = SWIG_Py_Void();
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return resultobj;
4412 fail:
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return NULL;
4418 }
4419
4420
4421 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj = 0;
4423 wxString *arg1 = 0 ;
4424 wxString result;
4425 bool temp1 = false ;
4426 PyObject * obj0 = 0 ;
4427 char * kwnames[] = {
4428 (char *) "name", NULL
4429 };
4430
4431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4432 {
4433 arg1 = wxString_in_helper(obj0);
4434 if (arg1 == NULL) SWIG_fail;
4435 temp1 = true;
4436 }
4437 {
4438 PyThreadState* __tstate = wxPyBeginAllowThreads();
4439 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 {
4444 #if wxUSE_UNICODE
4445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4446 #else
4447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4448 #endif
4449 }
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return resultobj;
4455 fail:
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return NULL;
4461 }
4462
4463
4464 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4465 PyObject *resultobj = 0;
4466 wxString *arg1 = 0 ;
4467 int result;
4468 bool temp1 = false ;
4469 PyObject * obj0 = 0 ;
4470 char * kwnames[] = {
4471 (char *) "name", NULL
4472 };
4473
4474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4475 {
4476 arg1 = wxString_in_helper(obj0);
4477 if (arg1 == NULL) SWIG_fail;
4478 temp1 = true;
4479 }
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4483 wxPyEndAllowThreads(__tstate);
4484 if (PyErr_Occurred()) SWIG_fail;
4485 }
4486 resultobj = SWIG_From_int(static_cast< int >(result));
4487 {
4488 if (temp1)
4489 delete arg1;
4490 }
4491 return resultobj;
4492 fail:
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return NULL;
4498 }
4499
4500
4501 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4502 PyObject *resultobj = 0;
4503 wxString *arg1 = 0 ;
4504 bool result;
4505 bool temp1 = false ;
4506 PyObject * obj0 = 0 ;
4507 char * kwnames[] = {
4508 (char *) "name", NULL
4509 };
4510
4511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4512 {
4513 arg1 = wxString_in_helper(obj0);
4514 if (arg1 == NULL) SWIG_fail;
4515 temp1 = true;
4516 }
4517 {
4518 PyThreadState* __tstate = wxPyBeginAllowThreads();
4519 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4520 wxPyEndAllowThreads(__tstate);
4521 if (PyErr_Occurred()) SWIG_fail;
4522 }
4523 {
4524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4525 }
4526 {
4527 if (temp1)
4528 delete arg1;
4529 }
4530 return resultobj;
4531 fail:
4532 {
4533 if (temp1)
4534 delete arg1;
4535 }
4536 return NULL;
4537 }
4538
4539
4540 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4541 PyObject *resultobj = 0;
4542 wxString *arg1 = 0 ;
4543 bool result;
4544 bool temp1 = false ;
4545 PyObject * obj0 = 0 ;
4546 char * kwnames[] = {
4547 (char *) "name", NULL
4548 };
4549
4550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4551 {
4552 arg1 = wxString_in_helper(obj0);
4553 if (arg1 == NULL) SWIG_fail;
4554 temp1 = true;
4555 }
4556 {
4557 PyThreadState* __tstate = wxPyBeginAllowThreads();
4558 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4559 wxPyEndAllowThreads(__tstate);
4560 if (PyErr_Occurred()) SWIG_fail;
4561 }
4562 {
4563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4564 }
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 return resultobj;
4570 fail:
4571 {
4572 if (temp1)
4573 delete arg1;
4574 }
4575 return NULL;
4576 }
4577
4578
4579 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580 PyObject *obj;
4581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4582 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4583 return SWIG_Py_Void();
4584 }
4585
4586 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4587 return SWIG_Python_InitShadowInstance(args);
4588 }
4589
4590 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4591 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4592 return 1;
4593 }
4594
4595
4596 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4597 PyObject *pyobj = 0;
4598
4599 {
4600 #if wxUSE_UNICODE
4601 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4602 #else
4603 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4604 #endif
4605 }
4606 return pyobj;
4607 }
4608
4609
4610 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4611 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4612 return 1;
4613 }
4614
4615
4616 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4617 PyObject *pyobj = 0;
4618
4619 {
4620 #if wxUSE_UNICODE
4621 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4622 #else
4623 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4624 #endif
4625 }
4626 return pyobj;
4627 }
4628
4629
4630 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4631 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4632 return 1;
4633 }
4634
4635
4636 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4637 PyObject *pyobj = 0;
4638
4639 {
4640 #if wxUSE_UNICODE
4641 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4642 #else
4643 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4644 #endif
4645 }
4646 return pyobj;
4647 }
4648
4649
4650 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4651 PyObject *resultobj = 0;
4652 long result;
4653
4654 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4655 {
4656 PyThreadState* __tstate = wxPyBeginAllowThreads();
4657 result = (long)wxNewId();
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_From_long(static_cast< long >(result));
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj = 0;
4670 long arg1 ;
4671 long val1 ;
4672 int ecode1 = 0 ;
4673 PyObject * obj0 = 0 ;
4674 char * kwnames[] = {
4675 (char *) "id", NULL
4676 };
4677
4678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4679 ecode1 = SWIG_AsVal_long(obj0, &val1);
4680 if (!SWIG_IsOK(ecode1)) {
4681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4682 }
4683 arg1 = static_cast< long >(val1);
4684 {
4685 PyThreadState* __tstate = wxPyBeginAllowThreads();
4686 wxRegisterId(arg1);
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 resultobj = SWIG_Py_Void();
4691 return resultobj;
4692 fail:
4693 return NULL;
4694 }
4695
4696
4697 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4698 PyObject *resultobj = 0;
4699 long result;
4700
4701 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4702 {
4703 PyThreadState* __tstate = wxPyBeginAllowThreads();
4704 result = (long)wxGetCurrentId();
4705 wxPyEndAllowThreads(__tstate);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 resultobj = SWIG_From_long(static_cast< long >(result));
4709 return resultobj;
4710 fail:
4711 return NULL;
4712 }
4713
4714
4715 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4716 PyObject *resultobj = 0;
4717 int arg1 ;
4718 bool result;
4719 int val1 ;
4720 int ecode1 = 0 ;
4721 PyObject * obj0 = 0 ;
4722 char * kwnames[] = {
4723 (char *) "id", NULL
4724 };
4725
4726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4727 ecode1 = SWIG_AsVal_int(obj0, &val1);
4728 if (!SWIG_IsOK(ecode1)) {
4729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4730 }
4731 arg1 = static_cast< int >(val1);
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (bool)wxIsStockID(arg1);
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 {
4739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4740 }
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4748 PyObject *resultobj = 0;
4749 int arg1 ;
4750 wxString *arg2 = 0 ;
4751 bool result;
4752 int val1 ;
4753 int ecode1 = 0 ;
4754 bool temp2 = false ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 char * kwnames[] = {
4758 (char *) "id",(char *) "label", NULL
4759 };
4760
4761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4762 ecode1 = SWIG_AsVal_int(obj0, &val1);
4763 if (!SWIG_IsOK(ecode1)) {
4764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4765 }
4766 arg1 = static_cast< int >(val1);
4767 {
4768 arg2 = wxString_in_helper(obj1);
4769 if (arg2 == NULL) SWIG_fail;
4770 temp2 = true;
4771 }
4772 {
4773 PyThreadState* __tstate = wxPyBeginAllowThreads();
4774 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4775 wxPyEndAllowThreads(__tstate);
4776 if (PyErr_Occurred()) SWIG_fail;
4777 }
4778 {
4779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4780 }
4781 {
4782 if (temp2)
4783 delete arg2;
4784 }
4785 return resultobj;
4786 fail:
4787 {
4788 if (temp2)
4789 delete arg2;
4790 }
4791 return NULL;
4792 }
4793
4794
4795 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4796 PyObject *resultobj = 0;
4797 int arg1 ;
4798 bool arg2 = (bool) true ;
4799 wxString arg3 = (wxString) wxPyEmptyString ;
4800 wxString result;
4801 int val1 ;
4802 int ecode1 = 0 ;
4803 bool val2 ;
4804 int ecode2 = 0 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 PyObject * obj2 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4813 ecode1 = SWIG_AsVal_int(obj0, &val1);
4814 if (!SWIG_IsOK(ecode1)) {
4815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4816 }
4817 arg1 = static_cast< int >(val1);
4818 if (obj1) {
4819 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4820 if (!SWIG_IsOK(ecode2)) {
4821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4822 }
4823 arg2 = static_cast< bool >(val2);
4824 }
4825 if (obj2) {
4826 {
4827 wxString* sptr = wxString_in_helper(obj2);
4828 if (sptr == NULL) SWIG_fail;
4829 arg3 = *sptr;
4830 delete sptr;
4831 }
4832 }
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 result = wxGetStockLabel(arg1,arg2,arg3);
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 {
4840 #if wxUSE_UNICODE
4841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4842 #else
4843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4844 #endif
4845 }
4846 return resultobj;
4847 fail:
4848 return NULL;
4849 }
4850
4851
4852 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4853 PyObject *resultobj = 0;
4854
4855 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4856 {
4857 if (!wxPyCheckForApp()) SWIG_fail;
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 wxBell();
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4871 PyObject *resultobj = 0;
4872
4873 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4874 {
4875 if (!wxPyCheckForApp()) SWIG_fail;
4876 PyThreadState* __tstate = wxPyBeginAllowThreads();
4877 wxEndBusyCursor();
4878 wxPyEndAllowThreads(__tstate);
4879 if (PyErr_Occurred()) SWIG_fail;
4880 }
4881 resultobj = SWIG_Py_Void();
4882 return resultobj;
4883 fail:
4884 return NULL;
4885 }
4886
4887
4888 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4889 PyObject *resultobj = 0;
4890 bool arg1 = (bool) true ;
4891 long result;
4892 bool val1 ;
4893 int ecode1 = 0 ;
4894 PyObject * obj0 = 0 ;
4895 char * kwnames[] = {
4896 (char *) "resetTimer", NULL
4897 };
4898
4899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4900 if (obj0) {
4901 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4902 if (!SWIG_IsOK(ecode1)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4904 }
4905 arg1 = static_cast< bool >(val1);
4906 }
4907 {
4908 PyThreadState* __tstate = wxPyBeginAllowThreads();
4909 result = (long)wxGetElapsedTime(arg1);
4910 wxPyEndAllowThreads(__tstate);
4911 if (PyErr_Occurred()) SWIG_fail;
4912 }
4913 resultobj = SWIG_From_long(static_cast< long >(result));
4914 return resultobj;
4915 fail:
4916 return NULL;
4917 }
4918
4919
4920 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4921 PyObject *resultobj = 0;
4922 bool result;
4923
4924 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4925 {
4926 PyThreadState* __tstate = wxPyBeginAllowThreads();
4927 result = (bool)wxIsBusy();
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 {
4932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4933 }
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941 PyObject *resultobj = 0;
4942 wxString result;
4943
4944 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4945 {
4946 PyThreadState* __tstate = wxPyBeginAllowThreads();
4947 result = wxNow();
4948 wxPyEndAllowThreads(__tstate);
4949 if (PyErr_Occurred()) SWIG_fail;
4950 }
4951 {
4952 #if wxUSE_UNICODE
4953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4954 #else
4955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4956 #endif
4957 }
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxString const &arg1_defvalue = wxPyEmptyString ;
4967 wxString *arg1 = (wxString *) &arg1_defvalue ;
4968 bool result;
4969 bool temp1 = false ;
4970 PyObject * obj0 = 0 ;
4971 char * kwnames[] = {
4972 (char *) "command", NULL
4973 };
4974
4975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4976 if (obj0) {
4977 {
4978 arg1 = wxString_in_helper(obj0);
4979 if (arg1 == NULL) SWIG_fail;
4980 temp1 = true;
4981 }
4982 }
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 result = (bool)wxShell((wxString const &)*arg1);
4986 wxPyEndAllowThreads(__tstate);
4987 if (PyErr_Occurred()) SWIG_fail;
4988 }
4989 {
4990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4991 }
4992 {
4993 if (temp1)
4994 delete arg1;
4995 }
4996 return resultobj;
4997 fail:
4998 {
4999 if (temp1)
5000 delete arg1;
5001 }
5002 return NULL;
5003 }
5004
5005
5006 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5007 PyObject *resultobj = 0;
5008
5009 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5010 {
5011 PyThreadState* __tstate = wxPyBeginAllowThreads();
5012 wxStartTimer();
5013 wxPyEndAllowThreads(__tstate);
5014 if (PyErr_Occurred()) SWIG_fail;
5015 }
5016 resultobj = SWIG_Py_Void();
5017 return resultobj;
5018 fail:
5019 return NULL;
5020 }
5021
5022
5023 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5024 PyObject *resultobj = 0;
5025 int *arg1 = (int *) 0 ;
5026 int *arg2 = (int *) 0 ;
5027 int result;
5028 int temp1 ;
5029 int res1 = SWIG_TMPOBJ ;
5030 int temp2 ;
5031 int res2 = SWIG_TMPOBJ ;
5032
5033 arg1 = &temp1;
5034 arg2 = &temp2;
5035 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5036 {
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (int)wxGetOsVersion(arg1,arg2);
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 resultobj = SWIG_From_int(static_cast< int >(result));
5043 if (SWIG_IsTmpObj(res1)) {
5044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5045 } else {
5046 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5048 }
5049 if (SWIG_IsTmpObj(res2)) {
5050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5051 } else {
5052 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5054 }
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5062 PyObject *resultobj = 0;
5063 wxString result;
5064
5065 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5066 {
5067 PyThreadState* __tstate = wxPyBeginAllowThreads();
5068 result = wxGetOsDescription();
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 {
5073 #if wxUSE_UNICODE
5074 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5075 #else
5076 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5077 #endif
5078 }
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5086 PyObject *resultobj = 0;
5087 wxMemorySize result;
5088
5089 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5090 {
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = wxGetFreeMemory();
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 {
5097 #if wxUSE_LONGLONG
5098 resultobj = PyLong_FromLongLong((&result)->GetValue());
5099 #else
5100 resultobj = PyInt_FromLong(result);
5101 #endif
5102 }
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5110 PyObject *resultobj = 0;
5111 wxShutdownFlags arg1 ;
5112 bool result;
5113 int val1 ;
5114 int ecode1 = 0 ;
5115 PyObject * obj0 = 0 ;
5116 char * kwnames[] = {
5117 (char *) "wFlags", NULL
5118 };
5119
5120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5121 ecode1 = SWIG_AsVal_int(obj0, &val1);
5122 if (!SWIG_IsOK(ecode1)) {
5123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5124 }
5125 arg1 = static_cast< wxShutdownFlags >(val1);
5126 {
5127 if (!wxPyCheckForApp()) SWIG_fail;
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 result = (bool)wxShutdown(arg1);
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 {
5134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5135 }
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5143 PyObject *resultobj = 0;
5144 int arg1 ;
5145 int val1 ;
5146 int ecode1 = 0 ;
5147 PyObject * obj0 = 0 ;
5148 char * kwnames[] = {
5149 (char *) "secs", NULL
5150 };
5151
5152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5153 ecode1 = SWIG_AsVal_int(obj0, &val1);
5154 if (!SWIG_IsOK(ecode1)) {
5155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5156 }
5157 arg1 = static_cast< int >(val1);
5158 {
5159 PyThreadState* __tstate = wxPyBeginAllowThreads();
5160 wxSleep(arg1);
5161 wxPyEndAllowThreads(__tstate);
5162 if (PyErr_Occurred()) SWIG_fail;
5163 }
5164 resultobj = SWIG_Py_Void();
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5172 PyObject *resultobj = 0;
5173 unsigned long arg1 ;
5174 unsigned long val1 ;
5175 int ecode1 = 0 ;
5176 PyObject * obj0 = 0 ;
5177 char * kwnames[] = {
5178 (char *) "milliseconds", NULL
5179 };
5180
5181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5182 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5183 if (!SWIG_IsOK(ecode1)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5185 }
5186 arg1 = static_cast< unsigned long >(val1);
5187 {
5188 PyThreadState* __tstate = wxPyBeginAllowThreads();
5189 wxMilliSleep(arg1);
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 resultobj = SWIG_Py_Void();
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj = 0;
5202 unsigned long arg1 ;
5203 unsigned long val1 ;
5204 int ecode1 = 0 ;
5205 PyObject * obj0 = 0 ;
5206 char * kwnames[] = {
5207 (char *) "microseconds", NULL
5208 };
5209
5210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5211 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5212 if (!SWIG_IsOK(ecode1)) {
5213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5214 }
5215 arg1 = static_cast< unsigned long >(val1);
5216 {
5217 PyThreadState* __tstate = wxPyBeginAllowThreads();
5218 wxMicroSleep(arg1);
5219 wxPyEndAllowThreads(__tstate);
5220 if (PyErr_Occurred()) SWIG_fail;
5221 }
5222 resultobj = SWIG_Py_Void();
5223 return resultobj;
5224 fail:
5225 return NULL;
5226 }
5227
5228
5229 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5230 PyObject *resultobj = 0;
5231 bool arg1 ;
5232 bool val1 ;
5233 int ecode1 = 0 ;
5234 PyObject * obj0 = 0 ;
5235 char * kwnames[] = {
5236 (char *) "enable", NULL
5237 };
5238
5239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5240 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5241 if (!SWIG_IsOK(ecode1)) {
5242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5243 }
5244 arg1 = static_cast< bool >(val1);
5245 {
5246 PyThreadState* __tstate = wxPyBeginAllowThreads();
5247 wxEnableTopLevelWindows(arg1);
5248 wxPyEndAllowThreads(__tstate);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 resultobj = SWIG_Py_Void();
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5259 PyObject *resultobj = 0;
5260 wxString *arg1 = 0 ;
5261 wxString result;
5262 bool temp1 = false ;
5263 PyObject * obj0 = 0 ;
5264 char * kwnames[] = {
5265 (char *) "in", NULL
5266 };
5267
5268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5269 {
5270 arg1 = wxString_in_helper(obj0);
5271 if (arg1 == NULL) SWIG_fail;
5272 temp1 = true;
5273 }
5274 {
5275 PyThreadState* __tstate = wxPyBeginAllowThreads();
5276 result = wxStripMenuCodes((wxString const &)*arg1);
5277 wxPyEndAllowThreads(__tstate);
5278 if (PyErr_Occurred()) SWIG_fail;
5279 }
5280 {
5281 #if wxUSE_UNICODE
5282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5283 #else
5284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5285 #endif
5286 }
5287 {
5288 if (temp1)
5289 delete arg1;
5290 }
5291 return resultobj;
5292 fail:
5293 {
5294 if (temp1)
5295 delete arg1;
5296 }
5297 return NULL;
5298 }
5299
5300
5301 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5302 PyObject *resultobj = 0;
5303 wxString result;
5304
5305 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5306 {
5307 PyThreadState* __tstate = wxPyBeginAllowThreads();
5308 result = wxGetEmailAddress();
5309 wxPyEndAllowThreads(__tstate);
5310 if (PyErr_Occurred()) SWIG_fail;
5311 }
5312 {
5313 #if wxUSE_UNICODE
5314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5315 #else
5316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5317 #endif
5318 }
5319 return resultobj;
5320 fail:
5321 return NULL;
5322 }
5323
5324
5325 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5326 PyObject *resultobj = 0;
5327 wxString result;
5328
5329 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5330 {
5331 PyThreadState* __tstate = wxPyBeginAllowThreads();
5332 result = wxGetHostName();
5333 wxPyEndAllowThreads(__tstate);
5334 if (PyErr_Occurred()) SWIG_fail;
5335 }
5336 {
5337 #if wxUSE_UNICODE
5338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5339 #else
5340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5341 #endif
5342 }
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxString result;
5352
5353 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 result = wxGetFullHostName();
5357 wxPyEndAllowThreads(__tstate);
5358 if (PyErr_Occurred()) SWIG_fail;
5359 }
5360 {
5361 #if wxUSE_UNICODE
5362 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5363 #else
5364 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5365 #endif
5366 }
5367 return resultobj;
5368 fail:
5369 return NULL;
5370 }
5371
5372
5373 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5374 PyObject *resultobj = 0;
5375 wxString result;
5376
5377 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5378 {
5379 PyThreadState* __tstate = wxPyBeginAllowThreads();
5380 result = wxGetUserId();
5381 wxPyEndAllowThreads(__tstate);
5382 if (PyErr_Occurred()) SWIG_fail;
5383 }
5384 {
5385 #if wxUSE_UNICODE
5386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5387 #else
5388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5389 #endif
5390 }
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5398 PyObject *resultobj = 0;
5399 wxString result;
5400
5401 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5402 {
5403 PyThreadState* __tstate = wxPyBeginAllowThreads();
5404 result = wxGetUserName();
5405 wxPyEndAllowThreads(__tstate);
5406 if (PyErr_Occurred()) SWIG_fail;
5407 }
5408 {
5409 #if wxUSE_UNICODE
5410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5411 #else
5412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5413 #endif
5414 }
5415 return resultobj;
5416 fail:
5417 return NULL;
5418 }
5419
5420
5421 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5422 PyObject *resultobj = 0;
5423 wxString result;
5424
5425 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5426 {
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = wxGetHomeDir();
5429 wxPyEndAllowThreads(__tstate);
5430 if (PyErr_Occurred()) SWIG_fail;
5431 }
5432 {
5433 #if wxUSE_UNICODE
5434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5435 #else
5436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5437 #endif
5438 }
5439 return resultobj;
5440 fail:
5441 return NULL;
5442 }
5443
5444
5445 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5446 PyObject *resultobj = 0;
5447 wxString const &arg1_defvalue = wxPyEmptyString ;
5448 wxString *arg1 = (wxString *) &arg1_defvalue ;
5449 wxString result;
5450 bool temp1 = false ;
5451 PyObject * obj0 = 0 ;
5452 char * kwnames[] = {
5453 (char *) "user", NULL
5454 };
5455
5456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5457 if (obj0) {
5458 {
5459 arg1 = wxString_in_helper(obj0);
5460 if (arg1 == NULL) SWIG_fail;
5461 temp1 = true;
5462 }
5463 }
5464 {
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 result = wxGetUserHome((wxString const &)*arg1);
5467 wxPyEndAllowThreads(__tstate);
5468 if (PyErr_Occurred()) SWIG_fail;
5469 }
5470 {
5471 #if wxUSE_UNICODE
5472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5473 #else
5474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5475 #endif
5476 }
5477 {
5478 if (temp1)
5479 delete arg1;
5480 }
5481 return resultobj;
5482 fail:
5483 {
5484 if (temp1)
5485 delete arg1;
5486 }
5487 return NULL;
5488 }
5489
5490
5491 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5492 PyObject *resultobj = 0;
5493 unsigned long result;
5494
5495 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5496 {
5497 PyThreadState* __tstate = wxPyBeginAllowThreads();
5498 result = (unsigned long)wxGetProcessId();
5499 wxPyEndAllowThreads(__tstate);
5500 if (PyErr_Occurred()) SWIG_fail;
5501 }
5502 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5503 return resultobj;
5504 fail:
5505 return NULL;
5506 }
5507
5508
5509 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5510 PyObject *resultobj = 0;
5511
5512 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5513 {
5514 PyThreadState* __tstate = wxPyBeginAllowThreads();
5515 wxTrap();
5516 wxPyEndAllowThreads(__tstate);
5517 if (PyErr_Occurred()) SWIG_fail;
5518 }
5519 resultobj = SWIG_Py_Void();
5520 return resultobj;
5521 fail:
5522 return NULL;
5523 }
5524
5525
5526 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5527 PyObject *resultobj = 0;
5528 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5529 wxString *arg1 = (wxString *) &arg1_defvalue ;
5530 wxString const &arg2_defvalue = wxPyEmptyString ;
5531 wxString *arg2 = (wxString *) &arg2_defvalue ;
5532 wxString const &arg3_defvalue = wxPyEmptyString ;
5533 wxString *arg3 = (wxString *) &arg3_defvalue ;
5534 wxString const &arg4_defvalue = wxPyEmptyString ;
5535 wxString *arg4 = (wxString *) &arg4_defvalue ;
5536 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5537 wxString *arg5 = (wxString *) &arg5_defvalue ;
5538 int arg6 = (int) 0 ;
5539 wxWindow *arg7 = (wxWindow *) NULL ;
5540 int arg8 = (int) -1 ;
5541 int arg9 = (int) -1 ;
5542 wxString result;
5543 bool temp1 = false ;
5544 bool temp2 = false ;
5545 bool temp3 = false ;
5546 bool temp4 = false ;
5547 bool temp5 = false ;
5548 int val6 ;
5549 int ecode6 = 0 ;
5550 void *argp7 = 0 ;
5551 int res7 = 0 ;
5552 int val8 ;
5553 int ecode8 = 0 ;
5554 int val9 ;
5555 int ecode9 = 0 ;
5556 PyObject * obj0 = 0 ;
5557 PyObject * obj1 = 0 ;
5558 PyObject * obj2 = 0 ;
5559 PyObject * obj3 = 0 ;
5560 PyObject * obj4 = 0 ;
5561 PyObject * obj5 = 0 ;
5562 PyObject * obj6 = 0 ;
5563 PyObject * obj7 = 0 ;
5564 PyObject * obj8 = 0 ;
5565 char * kwnames[] = {
5566 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5567 };
5568
5569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5570 if (obj0) {
5571 {
5572 arg1 = wxString_in_helper(obj0);
5573 if (arg1 == NULL) SWIG_fail;
5574 temp1 = true;
5575 }
5576 }
5577 if (obj1) {
5578 {
5579 arg2 = wxString_in_helper(obj1);
5580 if (arg2 == NULL) SWIG_fail;
5581 temp2 = true;
5582 }
5583 }
5584 if (obj2) {
5585 {
5586 arg3 = wxString_in_helper(obj2);
5587 if (arg3 == NULL) SWIG_fail;
5588 temp3 = true;
5589 }
5590 }
5591 if (obj3) {
5592 {
5593 arg4 = wxString_in_helper(obj3);
5594 if (arg4 == NULL) SWIG_fail;
5595 temp4 = true;
5596 }
5597 }
5598 if (obj4) {
5599 {
5600 arg5 = wxString_in_helper(obj4);
5601 if (arg5 == NULL) SWIG_fail;
5602 temp5 = true;
5603 }
5604 }
5605 if (obj5) {
5606 ecode6 = SWIG_AsVal_int(obj5, &val6);
5607 if (!SWIG_IsOK(ecode6)) {
5608 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5609 }
5610 arg6 = static_cast< int >(val6);
5611 }
5612 if (obj6) {
5613 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5614 if (!SWIG_IsOK(res7)) {
5615 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5616 }
5617 arg7 = reinterpret_cast< wxWindow * >(argp7);
5618 }
5619 if (obj7) {
5620 ecode8 = SWIG_AsVal_int(obj7, &val8);
5621 if (!SWIG_IsOK(ecode8)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5623 }
5624 arg8 = static_cast< int >(val8);
5625 }
5626 if (obj8) {
5627 ecode9 = SWIG_AsVal_int(obj8, &val9);
5628 if (!SWIG_IsOK(ecode9)) {
5629 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5630 }
5631 arg9 = static_cast< int >(val9);
5632 }
5633 {
5634 if (!wxPyCheckForApp()) SWIG_fail;
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 {
5641 #if wxUSE_UNICODE
5642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5643 #else
5644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5645 #endif
5646 }
5647 {
5648 if (temp1)
5649 delete arg1;
5650 }
5651 {
5652 if (temp2)
5653 delete arg2;
5654 }
5655 {
5656 if (temp3)
5657 delete arg3;
5658 }
5659 {
5660 if (temp4)
5661 delete arg4;
5662 }
5663 {
5664 if (temp5)
5665 delete arg5;
5666 }
5667 return resultobj;
5668 fail:
5669 {
5670 if (temp1)
5671 delete arg1;
5672 }
5673 {
5674 if (temp2)
5675 delete arg2;
5676 }
5677 {
5678 if (temp3)
5679 delete arg3;
5680 }
5681 {
5682 if (temp4)
5683 delete arg4;
5684 }
5685 {
5686 if (temp5)
5687 delete arg5;
5688 }
5689 return NULL;
5690 }
5691
5692
5693 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5694 PyObject *resultobj = 0;
5695 wxString *arg1 = 0 ;
5696 wxString *arg2 = 0 ;
5697 wxString const &arg3_defvalue = wxPyEmptyString ;
5698 wxString *arg3 = (wxString *) &arg3_defvalue ;
5699 wxWindow *arg4 = (wxWindow *) NULL ;
5700 wxString result;
5701 bool temp1 = false ;
5702 bool temp2 = false ;
5703 bool temp3 = false ;
5704 void *argp4 = 0 ;
5705 int res4 = 0 ;
5706 PyObject * obj0 = 0 ;
5707 PyObject * obj1 = 0 ;
5708 PyObject * obj2 = 0 ;
5709 PyObject * obj3 = 0 ;
5710 char * kwnames[] = {
5711 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5712 };
5713
5714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5715 {
5716 arg1 = wxString_in_helper(obj0);
5717 if (arg1 == NULL) SWIG_fail;
5718 temp1 = true;
5719 }
5720 {
5721 arg2 = wxString_in_helper(obj1);
5722 if (arg2 == NULL) SWIG_fail;
5723 temp2 = true;
5724 }
5725 if (obj2) {
5726 {
5727 arg3 = wxString_in_helper(obj2);
5728 if (arg3 == NULL) SWIG_fail;
5729 temp3 = true;
5730 }
5731 }
5732 if (obj3) {
5733 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5734 if (!SWIG_IsOK(res4)) {
5735 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5736 }
5737 arg4 = reinterpret_cast< wxWindow * >(argp4);
5738 }
5739 {
5740 if (!wxPyCheckForApp()) SWIG_fail;
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 {
5747 #if wxUSE_UNICODE
5748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5749 #else
5750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5751 #endif
5752 }
5753 {
5754 if (temp1)
5755 delete arg1;
5756 }
5757 {
5758 if (temp2)
5759 delete arg2;
5760 }
5761 {
5762 if (temp3)
5763 delete arg3;
5764 }
5765 return resultobj;
5766 fail:
5767 {
5768 if (temp1)
5769 delete arg1;
5770 }
5771 {
5772 if (temp2)
5773 delete arg2;
5774 }
5775 {
5776 if (temp3)
5777 delete arg3;
5778 }
5779 return NULL;
5780 }
5781
5782
5783 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5784 PyObject *resultobj = 0;
5785 wxString *arg1 = 0 ;
5786 wxString *arg2 = 0 ;
5787 wxString const &arg3_defvalue = wxPyEmptyString ;
5788 wxString *arg3 = (wxString *) &arg3_defvalue ;
5789 wxWindow *arg4 = (wxWindow *) NULL ;
5790 wxString result;
5791 bool temp1 = false ;
5792 bool temp2 = false ;
5793 bool temp3 = false ;
5794 void *argp4 = 0 ;
5795 int res4 = 0 ;
5796 PyObject * obj0 = 0 ;
5797 PyObject * obj1 = 0 ;
5798 PyObject * obj2 = 0 ;
5799 PyObject * obj3 = 0 ;
5800 char * kwnames[] = {
5801 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5802 };
5803
5804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5805 {
5806 arg1 = wxString_in_helper(obj0);
5807 if (arg1 == NULL) SWIG_fail;
5808 temp1 = true;
5809 }
5810 {
5811 arg2 = wxString_in_helper(obj1);
5812 if (arg2 == NULL) SWIG_fail;
5813 temp2 = true;
5814 }
5815 if (obj2) {
5816 {
5817 arg3 = wxString_in_helper(obj2);
5818 if (arg3 == NULL) SWIG_fail;
5819 temp3 = true;
5820 }
5821 }
5822 if (obj3) {
5823 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5824 if (!SWIG_IsOK(res4)) {
5825 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5826 }
5827 arg4 = reinterpret_cast< wxWindow * >(argp4);
5828 }
5829 {
5830 if (!wxPyCheckForApp()) SWIG_fail;
5831 PyThreadState* __tstate = wxPyBeginAllowThreads();
5832 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 {
5837 #if wxUSE_UNICODE
5838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5839 #else
5840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5841 #endif
5842 }
5843 {
5844 if (temp1)
5845 delete arg1;
5846 }
5847 {
5848 if (temp2)
5849 delete arg2;
5850 }
5851 {
5852 if (temp3)
5853 delete arg3;
5854 }
5855 return resultobj;
5856 fail:
5857 {
5858 if (temp1)
5859 delete arg1;
5860 }
5861 {
5862 if (temp2)
5863 delete arg2;
5864 }
5865 {
5866 if (temp3)
5867 delete arg3;
5868 }
5869 return NULL;
5870 }
5871
5872
5873 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5874 PyObject *resultobj = 0;
5875 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5876 wxString *arg1 = (wxString *) &arg1_defvalue ;
5877 wxString const &arg2_defvalue = wxPyEmptyString ;
5878 wxString *arg2 = (wxString *) &arg2_defvalue ;
5879 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5880 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5881 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5882 wxWindow *arg5 = (wxWindow *) NULL ;
5883 wxString result;
5884 bool temp1 = false ;
5885 bool temp2 = false ;
5886 long val3 ;
5887 int ecode3 = 0 ;
5888 wxPoint temp4 ;
5889 void *argp5 = 0 ;
5890 int res5 = 0 ;
5891 PyObject * obj0 = 0 ;
5892 PyObject * obj1 = 0 ;
5893 PyObject * obj2 = 0 ;
5894 PyObject * obj3 = 0 ;
5895 PyObject * obj4 = 0 ;
5896 char * kwnames[] = {
5897 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5898 };
5899
5900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5901 if (obj0) {
5902 {
5903 arg1 = wxString_in_helper(obj0);
5904 if (arg1 == NULL) SWIG_fail;
5905 temp1 = true;
5906 }
5907 }
5908 if (obj1) {
5909 {
5910 arg2 = wxString_in_helper(obj1);
5911 if (arg2 == NULL) SWIG_fail;
5912 temp2 = true;
5913 }
5914 }
5915 if (obj2) {
5916 ecode3 = SWIG_AsVal_long(obj2, &val3);
5917 if (!SWIG_IsOK(ecode3)) {
5918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5919 }
5920 arg3 = static_cast< long >(val3);
5921 }
5922 if (obj3) {
5923 {
5924 arg4 = &temp4;
5925 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5926 }
5927 }
5928 if (obj4) {
5929 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5930 if (!SWIG_IsOK(res5)) {
5931 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5932 }
5933 arg5 = reinterpret_cast< wxWindow * >(argp5);
5934 }
5935 {
5936 if (!wxPyCheckForApp()) SWIG_fail;
5937 PyThreadState* __tstate = wxPyBeginAllowThreads();
5938 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5939 wxPyEndAllowThreads(__tstate);
5940 if (PyErr_Occurred()) SWIG_fail;
5941 }
5942 {
5943 #if wxUSE_UNICODE
5944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5945 #else
5946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5947 #endif
5948 }
5949 {
5950 if (temp1)
5951 delete arg1;
5952 }
5953 {
5954 if (temp2)
5955 delete arg2;
5956 }
5957 return resultobj;
5958 fail:
5959 {
5960 if (temp1)
5961 delete arg1;
5962 }
5963 {
5964 if (temp2)
5965 delete arg2;
5966 }
5967 return NULL;
5968 }
5969
5970
5971 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5972 PyObject *resultobj = 0;
5973 wxString *arg1 = 0 ;
5974 wxString const &arg2_defvalue = wxPyEmptyString ;
5975 wxString *arg2 = (wxString *) &arg2_defvalue ;
5976 wxString const &arg3_defvalue = wxPyEmptyString ;
5977 wxString *arg3 = (wxString *) &arg3_defvalue ;
5978 wxWindow *arg4 = (wxWindow *) NULL ;
5979 int arg5 = (int) -1 ;
5980 int arg6 = (int) -1 ;
5981 bool arg7 = (bool) true ;
5982 wxString result;
5983 bool temp1 = false ;
5984 bool temp2 = false ;
5985 bool temp3 = false ;
5986 void *argp4 = 0 ;
5987 int res4 = 0 ;
5988 int val5 ;
5989 int ecode5 = 0 ;
5990 int val6 ;
5991 int ecode6 = 0 ;
5992 bool val7 ;
5993 int ecode7 = 0 ;
5994 PyObject * obj0 = 0 ;
5995 PyObject * obj1 = 0 ;
5996 PyObject * obj2 = 0 ;
5997 PyObject * obj3 = 0 ;
5998 PyObject * obj4 = 0 ;
5999 PyObject * obj5 = 0 ;
6000 PyObject * obj6 = 0 ;
6001 char * kwnames[] = {
6002 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6003 };
6004
6005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6006 {
6007 arg1 = wxString_in_helper(obj0);
6008 if (arg1 == NULL) SWIG_fail;
6009 temp1 = true;
6010 }
6011 if (obj1) {
6012 {
6013 arg2 = wxString_in_helper(obj1);
6014 if (arg2 == NULL) SWIG_fail;
6015 temp2 = true;
6016 }
6017 }
6018 if (obj2) {
6019 {
6020 arg3 = wxString_in_helper(obj2);
6021 if (arg3 == NULL) SWIG_fail;
6022 temp3 = true;
6023 }
6024 }
6025 if (obj3) {
6026 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6027 if (!SWIG_IsOK(res4)) {
6028 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6029 }
6030 arg4 = reinterpret_cast< wxWindow * >(argp4);
6031 }
6032 if (obj4) {
6033 ecode5 = SWIG_AsVal_int(obj4, &val5);
6034 if (!SWIG_IsOK(ecode5)) {
6035 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6036 }
6037 arg5 = static_cast< int >(val5);
6038 }
6039 if (obj5) {
6040 ecode6 = SWIG_AsVal_int(obj5, &val6);
6041 if (!SWIG_IsOK(ecode6)) {
6042 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6043 }
6044 arg6 = static_cast< int >(val6);
6045 }
6046 if (obj6) {
6047 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6048 if (!SWIG_IsOK(ecode7)) {
6049 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6050 }
6051 arg7 = static_cast< bool >(val7);
6052 }
6053 {
6054 if (!wxPyCheckForApp()) SWIG_fail;
6055 PyThreadState* __tstate = wxPyBeginAllowThreads();
6056 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6057 wxPyEndAllowThreads(__tstate);
6058 if (PyErr_Occurred()) SWIG_fail;
6059 }
6060 {
6061 #if wxUSE_UNICODE
6062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6063 #else
6064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6065 #endif
6066 }
6067 {
6068 if (temp1)
6069 delete arg1;
6070 }
6071 {
6072 if (temp2)
6073 delete arg2;
6074 }
6075 {
6076 if (temp3)
6077 delete arg3;
6078 }
6079 return resultobj;
6080 fail:
6081 {
6082 if (temp1)
6083 delete arg1;
6084 }
6085 {
6086 if (temp2)
6087 delete arg2;
6088 }
6089 {
6090 if (temp3)
6091 delete arg3;
6092 }
6093 return NULL;
6094 }
6095
6096
6097 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6098 PyObject *resultobj = 0;
6099 wxString *arg1 = 0 ;
6100 wxString const &arg2_defvalue = wxPyEmptyString ;
6101 wxString *arg2 = (wxString *) &arg2_defvalue ;
6102 wxString const &arg3_defvalue = wxPyEmptyString ;
6103 wxString *arg3 = (wxString *) &arg3_defvalue ;
6104 wxWindow *arg4 = (wxWindow *) NULL ;
6105 wxString result;
6106 bool temp1 = false ;
6107 bool temp2 = false ;
6108 bool temp3 = false ;
6109 void *argp4 = 0 ;
6110 int res4 = 0 ;
6111 PyObject * obj0 = 0 ;
6112 PyObject * obj1 = 0 ;
6113 PyObject * obj2 = 0 ;
6114 PyObject * obj3 = 0 ;
6115 char * kwnames[] = {
6116 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6117 };
6118
6119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6120 {
6121 arg1 = wxString_in_helper(obj0);
6122 if (arg1 == NULL) SWIG_fail;
6123 temp1 = true;
6124 }
6125 if (obj1) {
6126 {
6127 arg2 = wxString_in_helper(obj1);
6128 if (arg2 == NULL) SWIG_fail;
6129 temp2 = true;
6130 }
6131 }
6132 if (obj2) {
6133 {
6134 arg3 = wxString_in_helper(obj2);
6135 if (arg3 == NULL) SWIG_fail;
6136 temp3 = true;
6137 }
6138 }
6139 if (obj3) {
6140 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6141 if (!SWIG_IsOK(res4)) {
6142 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6143 }
6144 arg4 = reinterpret_cast< wxWindow * >(argp4);
6145 }
6146 {
6147 if (!wxPyCheckForApp()) SWIG_fail;
6148 PyThreadState* __tstate = wxPyBeginAllowThreads();
6149 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6150 wxPyEndAllowThreads(__tstate);
6151 if (PyErr_Occurred()) SWIG_fail;
6152 }
6153 {
6154 #if wxUSE_UNICODE
6155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6156 #else
6157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6158 #endif
6159 }
6160 {
6161 if (temp1)
6162 delete arg1;
6163 }
6164 {
6165 if (temp2)
6166 delete arg2;
6167 }
6168 {
6169 if (temp3)
6170 delete arg3;
6171 }
6172 return resultobj;
6173 fail:
6174 {
6175 if (temp1)
6176 delete arg1;
6177 }
6178 {
6179 if (temp2)
6180 delete arg2;
6181 }
6182 {
6183 if (temp3)
6184 delete arg3;
6185 }
6186 return NULL;
6187 }
6188
6189
6190 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj = 0;
6192 wxString *arg1 = 0 ;
6193 wxString *arg2 = 0 ;
6194 int arg3 ;
6195 wxString *arg4 = (wxString *) 0 ;
6196 wxWindow *arg5 = (wxWindow *) NULL ;
6197 int arg6 = (int) -1 ;
6198 int arg7 = (int) -1 ;
6199 bool arg8 = (bool) true ;
6200 int arg9 = (int) 150 ;
6201 int arg10 = (int) 200 ;
6202 wxString result;
6203 bool temp1 = false ;
6204 bool temp2 = false ;
6205 void *argp5 = 0 ;
6206 int res5 = 0 ;
6207 int val6 ;
6208 int ecode6 = 0 ;
6209 int val7 ;
6210 int ecode7 = 0 ;
6211 bool val8 ;
6212 int ecode8 = 0 ;
6213 int val9 ;
6214 int ecode9 = 0 ;
6215 int val10 ;
6216 int ecode10 = 0 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 PyObject * obj2 = 0 ;
6220 PyObject * obj3 = 0 ;
6221 PyObject * obj4 = 0 ;
6222 PyObject * obj5 = 0 ;
6223 PyObject * obj6 = 0 ;
6224 PyObject * obj7 = 0 ;
6225 PyObject * obj8 = 0 ;
6226 char * kwnames[] = {
6227 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6228 };
6229
6230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6231 {
6232 arg1 = wxString_in_helper(obj0);
6233 if (arg1 == NULL) SWIG_fail;
6234 temp1 = true;
6235 }
6236 {
6237 arg2 = wxString_in_helper(obj1);
6238 if (arg2 == NULL) SWIG_fail;
6239 temp2 = true;
6240 }
6241 {
6242 arg3 = PyList_Size(obj2);
6243 arg4 = wxString_LIST_helper(obj2);
6244 if (arg4 == NULL) SWIG_fail;
6245 }
6246 if (obj3) {
6247 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6248 if (!SWIG_IsOK(res5)) {
6249 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6250 }
6251 arg5 = reinterpret_cast< wxWindow * >(argp5);
6252 }
6253 if (obj4) {
6254 ecode6 = SWIG_AsVal_int(obj4, &val6);
6255 if (!SWIG_IsOK(ecode6)) {
6256 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6257 }
6258 arg6 = static_cast< int >(val6);
6259 }
6260 if (obj5) {
6261 ecode7 = SWIG_AsVal_int(obj5, &val7);
6262 if (!SWIG_IsOK(ecode7)) {
6263 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6264 }
6265 arg7 = static_cast< int >(val7);
6266 }
6267 if (obj6) {
6268 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6269 if (!SWIG_IsOK(ecode8)) {
6270 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6271 }
6272 arg8 = static_cast< bool >(val8);
6273 }
6274 if (obj7) {
6275 ecode9 = SWIG_AsVal_int(obj7, &val9);
6276 if (!SWIG_IsOK(ecode9)) {
6277 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6278 }
6279 arg9 = static_cast< int >(val9);
6280 }
6281 if (obj8) {
6282 ecode10 = SWIG_AsVal_int(obj8, &val10);
6283 if (!SWIG_IsOK(ecode10)) {
6284 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6285 }
6286 arg10 = static_cast< int >(val10);
6287 }
6288 {
6289 if (!wxPyCheckForApp()) SWIG_fail;
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 {
6296 #if wxUSE_UNICODE
6297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6298 #else
6299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6300 #endif
6301 }
6302 {
6303 if (temp1)
6304 delete arg1;
6305 }
6306 {
6307 if (temp2)
6308 delete arg2;
6309 }
6310 {
6311 if (arg4) delete [] arg4;
6312 }
6313 return resultobj;
6314 fail:
6315 {
6316 if (temp1)
6317 delete arg1;
6318 }
6319 {
6320 if (temp2)
6321 delete arg2;
6322 }
6323 {
6324 if (arg4) delete [] arg4;
6325 }
6326 return NULL;
6327 }
6328
6329
6330 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6331 PyObject *resultobj = 0;
6332 wxString *arg1 = 0 ;
6333 wxString *arg2 = 0 ;
6334 int arg3 ;
6335 wxString *arg4 = (wxString *) 0 ;
6336 wxWindow *arg5 = (wxWindow *) NULL ;
6337 int arg6 = (int) -1 ;
6338 int arg7 = (int) -1 ;
6339 bool arg8 = (bool) true ;
6340 int arg9 = (int) 150 ;
6341 int arg10 = (int) 200 ;
6342 int result;
6343 bool temp1 = false ;
6344 bool temp2 = false ;
6345 void *argp5 = 0 ;
6346 int res5 = 0 ;
6347 int val6 ;
6348 int ecode6 = 0 ;
6349 int val7 ;
6350 int ecode7 = 0 ;
6351 bool val8 ;
6352 int ecode8 = 0 ;
6353 int val9 ;
6354 int ecode9 = 0 ;
6355 int val10 ;
6356 int ecode10 = 0 ;
6357 PyObject * obj0 = 0 ;
6358 PyObject * obj1 = 0 ;
6359 PyObject * obj2 = 0 ;
6360 PyObject * obj3 = 0 ;
6361 PyObject * obj4 = 0 ;
6362 PyObject * obj5 = 0 ;
6363 PyObject * obj6 = 0 ;
6364 PyObject * obj7 = 0 ;
6365 PyObject * obj8 = 0 ;
6366 char * kwnames[] = {
6367 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6368 };
6369
6370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6371 {
6372 arg1 = wxString_in_helper(obj0);
6373 if (arg1 == NULL) SWIG_fail;
6374 temp1 = true;
6375 }
6376 {
6377 arg2 = wxString_in_helper(obj1);
6378 if (arg2 == NULL) SWIG_fail;
6379 temp2 = true;
6380 }
6381 {
6382 arg3 = PyList_Size(obj2);
6383 arg4 = wxString_LIST_helper(obj2);
6384 if (arg4 == NULL) SWIG_fail;
6385 }
6386 if (obj3) {
6387 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6388 if (!SWIG_IsOK(res5)) {
6389 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6390 }
6391 arg5 = reinterpret_cast< wxWindow * >(argp5);
6392 }
6393 if (obj4) {
6394 ecode6 = SWIG_AsVal_int(obj4, &val6);
6395 if (!SWIG_IsOK(ecode6)) {
6396 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6397 }
6398 arg6 = static_cast< int >(val6);
6399 }
6400 if (obj5) {
6401 ecode7 = SWIG_AsVal_int(obj5, &val7);
6402 if (!SWIG_IsOK(ecode7)) {
6403 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6404 }
6405 arg7 = static_cast< int >(val7);
6406 }
6407 if (obj6) {
6408 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6409 if (!SWIG_IsOK(ecode8)) {
6410 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6411 }
6412 arg8 = static_cast< bool >(val8);
6413 }
6414 if (obj7) {
6415 ecode9 = SWIG_AsVal_int(obj7, &val9);
6416 if (!SWIG_IsOK(ecode9)) {
6417 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6418 }
6419 arg9 = static_cast< int >(val9);
6420 }
6421 if (obj8) {
6422 ecode10 = SWIG_AsVal_int(obj8, &val10);
6423 if (!SWIG_IsOK(ecode10)) {
6424 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6425 }
6426 arg10 = static_cast< int >(val10);
6427 }
6428 {
6429 if (!wxPyCheckForApp()) SWIG_fail;
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6432 wxPyEndAllowThreads(__tstate);
6433 if (PyErr_Occurred()) SWIG_fail;
6434 }
6435 resultobj = SWIG_From_int(static_cast< int >(result));
6436 {
6437 if (temp1)
6438 delete arg1;
6439 }
6440 {
6441 if (temp2)
6442 delete arg2;
6443 }
6444 {
6445 if (arg4) delete [] arg4;
6446 }
6447 return resultobj;
6448 fail:
6449 {
6450 if (temp1)
6451 delete arg1;
6452 }
6453 {
6454 if (temp2)
6455 delete arg2;
6456 }
6457 {
6458 if (arg4) delete [] arg4;
6459 }
6460 return NULL;
6461 }
6462
6463
6464 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6465 PyObject *resultobj = 0;
6466 wxString *arg1 = 0 ;
6467 wxString const &arg2_defvalue = wxPyEmptyString ;
6468 wxString *arg2 = (wxString *) &arg2_defvalue ;
6469 int arg3 = (int) wxOK|wxCENTRE ;
6470 wxWindow *arg4 = (wxWindow *) NULL ;
6471 int arg5 = (int) -1 ;
6472 int arg6 = (int) -1 ;
6473 int result;
6474 bool temp1 = false ;
6475 bool temp2 = false ;
6476 int val3 ;
6477 int ecode3 = 0 ;
6478 void *argp4 = 0 ;
6479 int res4 = 0 ;
6480 int val5 ;
6481 int ecode5 = 0 ;
6482 int val6 ;
6483 int ecode6 = 0 ;
6484 PyObject * obj0 = 0 ;
6485 PyObject * obj1 = 0 ;
6486 PyObject * obj2 = 0 ;
6487 PyObject * obj3 = 0 ;
6488 PyObject * obj4 = 0 ;
6489 PyObject * obj5 = 0 ;
6490 char * kwnames[] = {
6491 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6492 };
6493
6494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6495 {
6496 arg1 = wxString_in_helper(obj0);
6497 if (arg1 == NULL) SWIG_fail;
6498 temp1 = true;
6499 }
6500 if (obj1) {
6501 {
6502 arg2 = wxString_in_helper(obj1);
6503 if (arg2 == NULL) SWIG_fail;
6504 temp2 = true;
6505 }
6506 }
6507 if (obj2) {
6508 ecode3 = SWIG_AsVal_int(obj2, &val3);
6509 if (!SWIG_IsOK(ecode3)) {
6510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6511 }
6512 arg3 = static_cast< int >(val3);
6513 }
6514 if (obj3) {
6515 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6516 if (!SWIG_IsOK(res4)) {
6517 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6518 }
6519 arg4 = reinterpret_cast< wxWindow * >(argp4);
6520 }
6521 if (obj4) {
6522 ecode5 = SWIG_AsVal_int(obj4, &val5);
6523 if (!SWIG_IsOK(ecode5)) {
6524 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6525 }
6526 arg5 = static_cast< int >(val5);
6527 }
6528 if (obj5) {
6529 ecode6 = SWIG_AsVal_int(obj5, &val6);
6530 if (!SWIG_IsOK(ecode6)) {
6531 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6532 }
6533 arg6 = static_cast< int >(val6);
6534 }
6535 {
6536 if (!wxPyCheckForApp()) SWIG_fail;
6537 PyThreadState* __tstate = wxPyBeginAllowThreads();
6538 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6539 wxPyEndAllowThreads(__tstate);
6540 if (PyErr_Occurred()) SWIG_fail;
6541 }
6542 resultobj = SWIG_From_int(static_cast< int >(result));
6543 {
6544 if (temp1)
6545 delete arg1;
6546 }
6547 {
6548 if (temp2)
6549 delete arg2;
6550 }
6551 return resultobj;
6552 fail:
6553 {
6554 if (temp1)
6555 delete arg1;
6556 }
6557 {
6558 if (temp2)
6559 delete arg2;
6560 }
6561 return NULL;
6562 }
6563
6564
6565 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6566 PyObject *resultobj = 0;
6567 wxString *arg1 = 0 ;
6568 wxString *arg2 = 0 ;
6569 wxString *arg3 = 0 ;
6570 long arg4 ;
6571 long arg5 = (long) 0 ;
6572 long arg6 = (long) 100 ;
6573 wxWindow *arg7 = (wxWindow *) NULL ;
6574 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6575 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6576 long result;
6577 bool temp1 = false ;
6578 bool temp2 = false ;
6579 bool temp3 = false ;
6580 long val4 ;
6581 int ecode4 = 0 ;
6582 long val5 ;
6583 int ecode5 = 0 ;
6584 long val6 ;
6585 int ecode6 = 0 ;
6586 void *argp7 = 0 ;
6587 int res7 = 0 ;
6588 wxPoint temp8 ;
6589 PyObject * obj0 = 0 ;
6590 PyObject * obj1 = 0 ;
6591 PyObject * obj2 = 0 ;
6592 PyObject * obj3 = 0 ;
6593 PyObject * obj4 = 0 ;
6594 PyObject * obj5 = 0 ;
6595 PyObject * obj6 = 0 ;
6596 PyObject * obj7 = 0 ;
6597 char * kwnames[] = {
6598 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6599 };
6600
6601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6602 {
6603 arg1 = wxString_in_helper(obj0);
6604 if (arg1 == NULL) SWIG_fail;
6605 temp1 = true;
6606 }
6607 {
6608 arg2 = wxString_in_helper(obj1);
6609 if (arg2 == NULL) SWIG_fail;
6610 temp2 = true;
6611 }
6612 {
6613 arg3 = wxString_in_helper(obj2);
6614 if (arg3 == NULL) SWIG_fail;
6615 temp3 = true;
6616 }
6617 ecode4 = SWIG_AsVal_long(obj3, &val4);
6618 if (!SWIG_IsOK(ecode4)) {
6619 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6620 }
6621 arg4 = static_cast< long >(val4);
6622 if (obj4) {
6623 ecode5 = SWIG_AsVal_long(obj4, &val5);
6624 if (!SWIG_IsOK(ecode5)) {
6625 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6626 }
6627 arg5 = static_cast< long >(val5);
6628 }
6629 if (obj5) {
6630 ecode6 = SWIG_AsVal_long(obj5, &val6);
6631 if (!SWIG_IsOK(ecode6)) {
6632 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6633 }
6634 arg6 = static_cast< long >(val6);
6635 }
6636 if (obj6) {
6637 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6638 if (!SWIG_IsOK(res7)) {
6639 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6640 }
6641 arg7 = reinterpret_cast< wxWindow * >(argp7);
6642 }
6643 if (obj7) {
6644 {
6645 arg8 = &temp8;
6646 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6647 }
6648 }
6649 {
6650 if (!wxPyCheckForApp()) SWIG_fail;
6651 PyThreadState* __tstate = wxPyBeginAllowThreads();
6652 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 resultobj = SWIG_From_long(static_cast< long >(result));
6657 {
6658 if (temp1)
6659 delete arg1;
6660 }
6661 {
6662 if (temp2)
6663 delete arg2;
6664 }
6665 {
6666 if (temp3)
6667 delete arg3;
6668 }
6669 return resultobj;
6670 fail:
6671 {
6672 if (temp1)
6673 delete arg1;
6674 }
6675 {
6676 if (temp2)
6677 delete arg2;
6678 }
6679 {
6680 if (temp3)
6681 delete arg3;
6682 }
6683 return NULL;
6684 }
6685
6686
6687 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6688 PyObject *resultobj = 0;
6689 bool result;
6690
6691 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6692 {
6693 if (!wxPyCheckForApp()) SWIG_fail;
6694 PyThreadState* __tstate = wxPyBeginAllowThreads();
6695 result = (bool)wxColourDisplay();
6696 wxPyEndAllowThreads(__tstate);
6697 if (PyErr_Occurred()) SWIG_fail;
6698 }
6699 {
6700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6701 }
6702 return resultobj;
6703 fail:
6704 return NULL;
6705 }
6706
6707
6708 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6709 PyObject *resultobj = 0;
6710 int result;
6711
6712 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6713 {
6714 if (!wxPyCheckForApp()) SWIG_fail;
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = (int)wxDisplayDepth();
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 resultobj = SWIG_From_int(static_cast< int >(result));
6721 return resultobj;
6722 fail:
6723 return NULL;
6724 }
6725
6726
6727 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6728 PyObject *resultobj = 0;
6729 int result;
6730
6731 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6732 {
6733 if (!wxPyCheckForApp()) SWIG_fail;
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 result = (int)wxGetDisplayDepth();
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 resultobj = SWIG_From_int(static_cast< int >(result));
6740 return resultobj;
6741 fail:
6742 return NULL;
6743 }
6744
6745
6746 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6747 PyObject *resultobj = 0;
6748 int *arg1 = (int *) 0 ;
6749 int *arg2 = (int *) 0 ;
6750 int temp1 ;
6751 int res1 = SWIG_TMPOBJ ;
6752 int temp2 ;
6753 int res2 = SWIG_TMPOBJ ;
6754
6755 arg1 = &temp1;
6756 arg2 = &temp2;
6757 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6758 {
6759 if (!wxPyCheckForApp()) SWIG_fail;
6760 PyThreadState* __tstate = wxPyBeginAllowThreads();
6761 wxDisplaySize(arg1,arg2);
6762 wxPyEndAllowThreads(__tstate);
6763 if (PyErr_Occurred()) SWIG_fail;
6764 }
6765 resultobj = SWIG_Py_Void();
6766 if (SWIG_IsTmpObj(res1)) {
6767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6768 } else {
6769 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6771 }
6772 if (SWIG_IsTmpObj(res2)) {
6773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6774 } else {
6775 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6777 }
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 wxSize result;
6787
6788 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6789 {
6790 if (!wxPyCheckForApp()) SWIG_fail;
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 result = wxGetDisplaySize();
6793 wxPyEndAllowThreads(__tstate);
6794 if (PyErr_Occurred()) SWIG_fail;
6795 }
6796 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6797 return resultobj;
6798 fail:
6799 return NULL;
6800 }
6801
6802
6803 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6804 PyObject *resultobj = 0;
6805 int *arg1 = (int *) 0 ;
6806 int *arg2 = (int *) 0 ;
6807 int temp1 ;
6808 int res1 = SWIG_TMPOBJ ;
6809 int temp2 ;
6810 int res2 = SWIG_TMPOBJ ;
6811
6812 arg1 = &temp1;
6813 arg2 = &temp2;
6814 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6815 {
6816 if (!wxPyCheckForApp()) SWIG_fail;
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 wxDisplaySizeMM(arg1,arg2);
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_Py_Void();
6823 if (SWIG_IsTmpObj(res1)) {
6824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6825 } else {
6826 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6828 }
6829 if (SWIG_IsTmpObj(res2)) {
6830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6831 } else {
6832 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6834 }
6835 return resultobj;
6836 fail:
6837 return NULL;
6838 }
6839
6840
6841 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6842 PyObject *resultobj = 0;
6843 wxSize result;
6844
6845 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6846 {
6847 if (!wxPyCheckForApp()) SWIG_fail;
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 result = wxGetDisplaySizeMM();
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6861 PyObject *resultobj = 0;
6862 int *arg1 = (int *) 0 ;
6863 int *arg2 = (int *) 0 ;
6864 int *arg3 = (int *) 0 ;
6865 int *arg4 = (int *) 0 ;
6866 int temp1 ;
6867 int res1 = SWIG_TMPOBJ ;
6868 int temp2 ;
6869 int res2 = SWIG_TMPOBJ ;
6870 int temp3 ;
6871 int res3 = SWIG_TMPOBJ ;
6872 int temp4 ;
6873 int res4 = SWIG_TMPOBJ ;
6874
6875 arg1 = &temp1;
6876 arg2 = &temp2;
6877 arg3 = &temp3;
6878 arg4 = &temp4;
6879 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6880 {
6881 if (!wxPyCheckForApp()) SWIG_fail;
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_Py_Void();
6888 if (SWIG_IsTmpObj(res1)) {
6889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6890 } else {
6891 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6893 }
6894 if (SWIG_IsTmpObj(res2)) {
6895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6896 } else {
6897 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6899 }
6900 if (SWIG_IsTmpObj(res3)) {
6901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6902 } else {
6903 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6905 }
6906 if (SWIG_IsTmpObj(res4)) {
6907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6908 } else {
6909 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6911 }
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6919 PyObject *resultobj = 0;
6920 wxRect result;
6921
6922 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6923 {
6924 if (!wxPyCheckForApp()) SWIG_fail;
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 result = wxGetClientDisplayRect();
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6938 PyObject *resultobj = 0;
6939 wxCursor *arg1 = 0 ;
6940 void *argp1 = 0 ;
6941 int res1 = 0 ;
6942 PyObject * obj0 = 0 ;
6943 char * kwnames[] = {
6944 (char *) "cursor", NULL
6945 };
6946
6947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6948 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6949 if (!SWIG_IsOK(res1)) {
6950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6951 }
6952 if (!argp1) {
6953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6954 }
6955 arg1 = reinterpret_cast< wxCursor * >(argp1);
6956 {
6957 if (!wxPyCheckForApp()) SWIG_fail;
6958 PyThreadState* __tstate = wxPyBeginAllowThreads();
6959 wxSetCursor(*arg1);
6960 wxPyEndAllowThreads(__tstate);
6961 if (PyErr_Occurred()) SWIG_fail;
6962 }
6963 resultobj = SWIG_Py_Void();
6964 return resultobj;
6965 fail:
6966 return NULL;
6967 }
6968
6969
6970 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6971 PyObject *resultobj = 0;
6972 void *result = 0 ;
6973
6974 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6975 {
6976 if (!wxPyCheckForApp()) SWIG_fail;
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (void *)wxGetXDisplay();
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj = 0;
6991 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6992 void *argp1 = 0 ;
6993 int res1 = 0 ;
6994 PyObject * obj0 = 0 ;
6995 char * kwnames[] = {
6996 (char *) "cursor", NULL
6997 };
6998
6999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7000 if (obj0) {
7001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7002 if (!SWIG_IsOK(res1)) {
7003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7004 }
7005 arg1 = reinterpret_cast< wxCursor * >(argp1);
7006 }
7007 {
7008 if (!wxPyCheckForApp()) SWIG_fail;
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 wxBeginBusyCursor(arg1);
7011 wxPyEndAllowThreads(__tstate);
7012 if (PyErr_Occurred()) SWIG_fail;
7013 }
7014 resultobj = SWIG_Py_Void();
7015 return resultobj;
7016 fail:
7017 return NULL;
7018 }
7019
7020
7021 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7022 PyObject *resultobj = 0;
7023 wxPoint result;
7024
7025 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7026 {
7027 if (!wxPyCheckForApp()) SWIG_fail;
7028 PyThreadState* __tstate = wxPyBeginAllowThreads();
7029 result = wxGetMousePosition();
7030 wxPyEndAllowThreads(__tstate);
7031 if (PyErr_Occurred()) SWIG_fail;
7032 }
7033 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7034 return resultobj;
7035 fail:
7036 return NULL;
7037 }
7038
7039
7040 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7041 PyObject *resultobj = 0;
7042 wxWindow *result = 0 ;
7043
7044 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7045 {
7046 if (!wxPyCheckForApp()) SWIG_fail;
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 result = (wxWindow *)FindWindowAtPointer();
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 {
7053 resultobj = wxPyMake_wxObject(result, 0);
7054 }
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062 PyObject *resultobj = 0;
7063 wxWindow *result = 0 ;
7064
7065 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7066 {
7067 if (!wxPyCheckForApp()) SWIG_fail;
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (wxWindow *)wxGetActiveWindow();
7070 wxPyEndAllowThreads(__tstate);
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 {
7074 resultobj = wxPyMake_wxObject(result, 0);
7075 }
7076 return resultobj;
7077 fail:
7078 return NULL;
7079 }
7080
7081
7082 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7083 PyObject *resultobj = 0;
7084 wxPoint *arg1 = 0 ;
7085 wxWindow *result = 0 ;
7086 wxPoint temp1 ;
7087 PyObject * obj0 = 0 ;
7088 char * kwnames[] = {
7089 (char *) "pt", NULL
7090 };
7091
7092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7093 {
7094 arg1 = &temp1;
7095 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7096 }
7097 {
7098 if (!wxPyCheckForApp()) SWIG_fail;
7099 PyThreadState* __tstate = wxPyBeginAllowThreads();
7100 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 {
7105 resultobj = wxPyMake_wxObject(result, 0);
7106 }
7107 return resultobj;
7108 fail:
7109 return NULL;
7110 }
7111
7112
7113 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7114 PyObject *resultobj = 0;
7115 wxPoint *arg1 = 0 ;
7116 wxWindow *result = 0 ;
7117 wxPoint temp1 ;
7118 PyObject * obj0 = 0 ;
7119 char * kwnames[] = {
7120 (char *) "pt", NULL
7121 };
7122
7123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7124 {
7125 arg1 = &temp1;
7126 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7127 }
7128 {
7129 if (!wxPyCheckForApp()) SWIG_fail;
7130 PyThreadState* __tstate = wxPyBeginAllowThreads();
7131 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = wxPyMake_wxObject(result, 0);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj = 0;
7146 wxWindow *arg1 = (wxWindow *) 0 ;
7147 wxWindow *result = 0 ;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 PyObject * obj0 = 0 ;
7151 char * kwnames[] = {
7152 (char *) "win", NULL
7153 };
7154
7155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7157 if (!SWIG_IsOK(res1)) {
7158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7159 }
7160 arg1 = reinterpret_cast< wxWindow * >(argp1);
7161 {
7162 if (!wxPyCheckForApp()) SWIG_fail;
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 result = (wxWindow *)wxGetTopLevelParent(arg1);
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 {
7169 resultobj = wxPyMake_wxObject(result, 0);
7170 }
7171 return resultobj;
7172 fail:
7173 return NULL;
7174 }
7175
7176
7177 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7178 PyObject *resultobj = 0;
7179 wxString *arg1 = 0 ;
7180 bool result;
7181 bool temp1 = false ;
7182 PyObject * obj0 = 0 ;
7183 char * kwnames[] = {
7184 (char *) "url", NULL
7185 };
7186
7187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7188 {
7189 arg1 = wxString_in_helper(obj0);
7190 if (arg1 == NULL) SWIG_fail;
7191 temp1 = true;
7192 }
7193 {
7194 PyThreadState* __tstate = wxPyBeginAllowThreads();
7195 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7196 wxPyEndAllowThreads(__tstate);
7197 if (PyErr_Occurred()) SWIG_fail;
7198 }
7199 {
7200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7201 }
7202 {
7203 if (temp1)
7204 delete arg1;
7205 }
7206 return resultobj;
7207 fail:
7208 {
7209 if (temp1)
7210 delete arg1;
7211 }
7212 return NULL;
7213 }
7214
7215
7216 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7217 PyObject *resultobj = 0;
7218 wxKeyCode arg1 ;
7219 bool result;
7220 int val1 ;
7221 int ecode1 = 0 ;
7222 PyObject * obj0 = 0 ;
7223 char * kwnames[] = {
7224 (char *) "key", NULL
7225 };
7226
7227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7228 ecode1 = SWIG_AsVal_int(obj0, &val1);
7229 if (!SWIG_IsOK(ecode1)) {
7230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7231 }
7232 arg1 = static_cast< wxKeyCode >(val1);
7233 {
7234 if (!wxPyCheckForApp()) SWIG_fail;
7235 PyThreadState* __tstate = wxPyBeginAllowThreads();
7236 result = (bool)wxGetKeyState(arg1);
7237 wxPyEndAllowThreads(__tstate);
7238 if (PyErr_Occurred()) SWIG_fail;
7239 }
7240 {
7241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7242 }
7243 return resultobj;
7244 fail:
7245 return NULL;
7246 }
7247
7248
7249 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7250 PyObject *resultobj = 0;
7251 wxMouseState *result = 0 ;
7252
7253 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7254 {
7255 PyThreadState* __tstate = wxPyBeginAllowThreads();
7256 result = (wxMouseState *)new wxMouseState();
7257 wxPyEndAllowThreads(__tstate);
7258 if (PyErr_Occurred()) SWIG_fail;
7259 }
7260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7268 PyObject *resultobj = 0;
7269 wxMouseState *arg1 = (wxMouseState *) 0 ;
7270 void *argp1 = 0 ;
7271 int res1 = 0 ;
7272 PyObject *swig_obj[1] ;
7273
7274 if (!args) SWIG_fail;
7275 swig_obj[0] = args;
7276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7277 if (!SWIG_IsOK(res1)) {
7278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7279 }
7280 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 delete arg1;
7284
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 resultobj = SWIG_Py_Void();
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7296 PyObject *resultobj = 0;
7297 wxMouseState *arg1 = (wxMouseState *) 0 ;
7298 int result;
7299 void *argp1 = 0 ;
7300 int res1 = 0 ;
7301 PyObject *swig_obj[1] ;
7302
7303 if (!args) SWIG_fail;
7304 swig_obj[0] = args;
7305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7306 if (!SWIG_IsOK(res1)) {
7307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7308 }
7309 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7310 {
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 result = (int)(arg1)->GetX();
7313 wxPyEndAllowThreads(__tstate);
7314 if (PyErr_Occurred()) SWIG_fail;
7315 }
7316 resultobj = SWIG_From_int(static_cast< int >(result));
7317 return resultobj;
7318 fail:
7319 return NULL;
7320 }
7321
7322
7323 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7324 PyObject *resultobj = 0;
7325 wxMouseState *arg1 = (wxMouseState *) 0 ;
7326 int result;
7327 void *argp1 = 0 ;
7328 int res1 = 0 ;
7329 PyObject *swig_obj[1] ;
7330
7331 if (!args) SWIG_fail;
7332 swig_obj[0] = args;
7333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7334 if (!SWIG_IsOK(res1)) {
7335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7336 }
7337 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (int)(arg1)->GetY();
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_From_int(static_cast< int >(result));
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7352 PyObject *resultobj = 0;
7353 wxMouseState *arg1 = (wxMouseState *) 0 ;
7354 bool result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 PyObject *swig_obj[1] ;
7358
7359 if (!args) SWIG_fail;
7360 swig_obj[0] = args;
7361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7362 if (!SWIG_IsOK(res1)) {
7363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7364 }
7365 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 result = (bool)(arg1)->LeftDown();
7369 wxPyEndAllowThreads(__tstate);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 {
7373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7374 }
7375 return resultobj;
7376 fail:
7377 return NULL;
7378 }
7379
7380
7381 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7382 PyObject *resultobj = 0;
7383 wxMouseState *arg1 = (wxMouseState *) 0 ;
7384 bool result;
7385 void *argp1 = 0 ;
7386 int res1 = 0 ;
7387 PyObject *swig_obj[1] ;
7388
7389 if (!args) SWIG_fail;
7390 swig_obj[0] = args;
7391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7392 if (!SWIG_IsOK(res1)) {
7393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7394 }
7395 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7396 {
7397 PyThreadState* __tstate = wxPyBeginAllowThreads();
7398 result = (bool)(arg1)->MiddleDown();
7399 wxPyEndAllowThreads(__tstate);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 {
7403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7404 }
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7412 PyObject *resultobj = 0;
7413 wxMouseState *arg1 = (wxMouseState *) 0 ;
7414 bool result;
7415 void *argp1 = 0 ;
7416 int res1 = 0 ;
7417 PyObject *swig_obj[1] ;
7418
7419 if (!args) SWIG_fail;
7420 swig_obj[0] = args;
7421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7422 if (!SWIG_IsOK(res1)) {
7423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7424 }
7425 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7426 {
7427 PyThreadState* __tstate = wxPyBeginAllowThreads();
7428 result = (bool)(arg1)->RightDown();
7429 wxPyEndAllowThreads(__tstate);
7430 if (PyErr_Occurred()) SWIG_fail;
7431 }
7432 {
7433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7434 }
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7442 PyObject *resultobj = 0;
7443 wxMouseState *arg1 = (wxMouseState *) 0 ;
7444 bool result;
7445 void *argp1 = 0 ;
7446 int res1 = 0 ;
7447 PyObject *swig_obj[1] ;
7448
7449 if (!args) SWIG_fail;
7450 swig_obj[0] = args;
7451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7452 if (!SWIG_IsOK(res1)) {
7453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7454 }
7455 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7456 {
7457 PyThreadState* __tstate = wxPyBeginAllowThreads();
7458 result = (bool)(arg1)->ControlDown();
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 {
7463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7464 }
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7472 PyObject *resultobj = 0;
7473 wxMouseState *arg1 = (wxMouseState *) 0 ;
7474 bool result;
7475 void *argp1 = 0 ;
7476 int res1 = 0 ;
7477 PyObject *swig_obj[1] ;
7478
7479 if (!args) SWIG_fail;
7480 swig_obj[0] = args;
7481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7482 if (!SWIG_IsOK(res1)) {
7483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7484 }
7485 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7486 {
7487 PyThreadState* __tstate = wxPyBeginAllowThreads();
7488 result = (bool)(arg1)->ShiftDown();
7489 wxPyEndAllowThreads(__tstate);
7490 if (PyErr_Occurred()) SWIG_fail;
7491 }
7492 {
7493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7494 }
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7502 PyObject *resultobj = 0;
7503 wxMouseState *arg1 = (wxMouseState *) 0 ;
7504 bool result;
7505 void *argp1 = 0 ;
7506 int res1 = 0 ;
7507 PyObject *swig_obj[1] ;
7508
7509 if (!args) SWIG_fail;
7510 swig_obj[0] = args;
7511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7512 if (!SWIG_IsOK(res1)) {
7513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7514 }
7515 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7516 {
7517 PyThreadState* __tstate = wxPyBeginAllowThreads();
7518 result = (bool)(arg1)->AltDown();
7519 wxPyEndAllowThreads(__tstate);
7520 if (PyErr_Occurred()) SWIG_fail;
7521 }
7522 {
7523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7524 }
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7532 PyObject *resultobj = 0;
7533 wxMouseState *arg1 = (wxMouseState *) 0 ;
7534 bool result;
7535 void *argp1 = 0 ;
7536 int res1 = 0 ;
7537 PyObject *swig_obj[1] ;
7538
7539 if (!args) SWIG_fail;
7540 swig_obj[0] = args;
7541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7542 if (!SWIG_IsOK(res1)) {
7543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7544 }
7545 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7546 {
7547 PyThreadState* __tstate = wxPyBeginAllowThreads();
7548 result = (bool)(arg1)->MetaDown();
7549 wxPyEndAllowThreads(__tstate);
7550 if (PyErr_Occurred()) SWIG_fail;
7551 }
7552 {
7553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7554 }
7555 return resultobj;
7556 fail:
7557 return NULL;
7558 }
7559
7560
7561 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7562 PyObject *resultobj = 0;
7563 wxMouseState *arg1 = (wxMouseState *) 0 ;
7564 bool result;
7565 void *argp1 = 0 ;
7566 int res1 = 0 ;
7567 PyObject *swig_obj[1] ;
7568
7569 if (!args) SWIG_fail;
7570 swig_obj[0] = args;
7571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7572 if (!SWIG_IsOK(res1)) {
7573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7574 }
7575 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 result = (bool)(arg1)->CmdDown();
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 {
7583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7584 }
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7592 PyObject *resultobj = 0;
7593 wxMouseState *arg1 = (wxMouseState *) 0 ;
7594 int arg2 ;
7595 void *argp1 = 0 ;
7596 int res1 = 0 ;
7597 int val2 ;
7598 int ecode2 = 0 ;
7599 PyObject * obj0 = 0 ;
7600 PyObject * obj1 = 0 ;
7601 char * kwnames[] = {
7602 (char *) "self",(char *) "x", NULL
7603 };
7604
7605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7609 }
7610 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7611 ecode2 = SWIG_AsVal_int(obj1, &val2);
7612 if (!SWIG_IsOK(ecode2)) {
7613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7614 }
7615 arg2 = static_cast< int >(val2);
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 (arg1)->SetX(arg2);
7619 wxPyEndAllowThreads(__tstate);
7620 if (PyErr_Occurred()) SWIG_fail;
7621 }
7622 resultobj = SWIG_Py_Void();
7623 return resultobj;
7624 fail:
7625 return NULL;
7626 }
7627
7628
7629 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7630 PyObject *resultobj = 0;
7631 wxMouseState *arg1 = (wxMouseState *) 0 ;
7632 int arg2 ;
7633 void *argp1 = 0 ;
7634 int res1 = 0 ;
7635 int val2 ;
7636 int ecode2 = 0 ;
7637 PyObject * obj0 = 0 ;
7638 PyObject * obj1 = 0 ;
7639 char * kwnames[] = {
7640 (char *) "self",(char *) "y", NULL
7641 };
7642
7643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7645 if (!SWIG_IsOK(res1)) {
7646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7647 }
7648 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7649 ecode2 = SWIG_AsVal_int(obj1, &val2);
7650 if (!SWIG_IsOK(ecode2)) {
7651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7652 }
7653 arg2 = static_cast< int >(val2);
7654 {
7655 PyThreadState* __tstate = wxPyBeginAllowThreads();
7656 (arg1)->SetY(arg2);
7657 wxPyEndAllowThreads(__tstate);
7658 if (PyErr_Occurred()) SWIG_fail;
7659 }
7660 resultobj = SWIG_Py_Void();
7661 return resultobj;
7662 fail:
7663 return NULL;
7664 }
7665
7666
7667 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7668 PyObject *resultobj = 0;
7669 wxMouseState *arg1 = (wxMouseState *) 0 ;
7670 bool arg2 ;
7671 void *argp1 = 0 ;
7672 int res1 = 0 ;
7673 bool val2 ;
7674 int ecode2 = 0 ;
7675 PyObject * obj0 = 0 ;
7676 PyObject * obj1 = 0 ;
7677 char * kwnames[] = {
7678 (char *) "self",(char *) "down", NULL
7679 };
7680
7681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7683 if (!SWIG_IsOK(res1)) {
7684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7685 }
7686 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7688 if (!SWIG_IsOK(ecode2)) {
7689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7690 }
7691 arg2 = static_cast< bool >(val2);
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 (arg1)->SetLeftDown(arg2);
7695 wxPyEndAllowThreads(__tstate);
7696 if (PyErr_Occurred()) SWIG_fail;
7697 }
7698 resultobj = SWIG_Py_Void();
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj = 0;
7707 wxMouseState *arg1 = (wxMouseState *) 0 ;
7708 bool arg2 ;
7709 void *argp1 = 0 ;
7710 int res1 = 0 ;
7711 bool val2 ;
7712 int ecode2 = 0 ;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 char * kwnames[] = {
7716 (char *) "self",(char *) "down", NULL
7717 };
7718
7719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7723 }
7724 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7725 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7728 }
7729 arg2 = static_cast< bool >(val2);
7730 {
7731 PyThreadState* __tstate = wxPyBeginAllowThreads();
7732 (arg1)->SetMiddleDown(arg2);
7733 wxPyEndAllowThreads(__tstate);
7734 if (PyErr_Occurred()) SWIG_fail;
7735 }
7736 resultobj = SWIG_Py_Void();
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj = 0;
7745 wxMouseState *arg1 = (wxMouseState *) 0 ;
7746 bool arg2 ;
7747 void *argp1 = 0 ;
7748 int res1 = 0 ;
7749 bool val2 ;
7750 int ecode2 = 0 ;
7751 PyObject * obj0 = 0 ;
7752 PyObject * obj1 = 0 ;
7753 char * kwnames[] = {
7754 (char *) "self",(char *) "down", NULL
7755 };
7756
7757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7761 }
7762 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7763 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7764 if (!SWIG_IsOK(ecode2)) {
7765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7766 }
7767 arg2 = static_cast< bool >(val2);
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 (arg1)->SetRightDown(arg2);
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 resultobj = SWIG_Py_Void();
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7782 PyObject *resultobj = 0;
7783 wxMouseState *arg1 = (wxMouseState *) 0 ;
7784 bool arg2 ;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 bool val2 ;
7788 int ecode2 = 0 ;
7789 PyObject * obj0 = 0 ;
7790 PyObject * obj1 = 0 ;
7791 char * kwnames[] = {
7792 (char *) "self",(char *) "down", NULL
7793 };
7794
7795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7797 if (!SWIG_IsOK(res1)) {
7798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7799 }
7800 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7802 if (!SWIG_IsOK(ecode2)) {
7803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7804 }
7805 arg2 = static_cast< bool >(val2);
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 (arg1)->SetControlDown(arg2);
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 resultobj = SWIG_Py_Void();
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7820 PyObject *resultobj = 0;
7821 wxMouseState *arg1 = (wxMouseState *) 0 ;
7822 bool arg2 ;
7823 void *argp1 = 0 ;
7824 int res1 = 0 ;
7825 bool val2 ;
7826 int ecode2 = 0 ;
7827 PyObject * obj0 = 0 ;
7828 PyObject * obj1 = 0 ;
7829 char * kwnames[] = {
7830 (char *) "self",(char *) "down", NULL
7831 };
7832
7833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7835 if (!SWIG_IsOK(res1)) {
7836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7837 }
7838 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7839 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7840 if (!SWIG_IsOK(ecode2)) {
7841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7842 }
7843 arg2 = static_cast< bool >(val2);
7844 {
7845 PyThreadState* __tstate = wxPyBeginAllowThreads();
7846 (arg1)->SetShiftDown(arg2);
7847 wxPyEndAllowThreads(__tstate);
7848 if (PyErr_Occurred()) SWIG_fail;
7849 }
7850 resultobj = SWIG_Py_Void();
7851 return resultobj;
7852 fail:
7853 return NULL;
7854 }
7855
7856
7857 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7858 PyObject *resultobj = 0;
7859 wxMouseState *arg1 = (wxMouseState *) 0 ;
7860 bool arg2 ;
7861 void *argp1 = 0 ;
7862 int res1 = 0 ;
7863 bool val2 ;
7864 int ecode2 = 0 ;
7865 PyObject * obj0 = 0 ;
7866 PyObject * obj1 = 0 ;
7867 char * kwnames[] = {
7868 (char *) "self",(char *) "down", NULL
7869 };
7870
7871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7873 if (!SWIG_IsOK(res1)) {
7874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7875 }
7876 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7878 if (!SWIG_IsOK(ecode2)) {
7879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7880 }
7881 arg2 = static_cast< bool >(val2);
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 (arg1)->SetAltDown(arg2);
7885 wxPyEndAllowThreads(__tstate);
7886 if (PyErr_Occurred()) SWIG_fail;
7887 }
7888 resultobj = SWIG_Py_Void();
7889 return resultobj;
7890 fail:
7891 return NULL;
7892 }
7893
7894
7895 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7896 PyObject *resultobj = 0;
7897 wxMouseState *arg1 = (wxMouseState *) 0 ;
7898 bool arg2 ;
7899 void *argp1 = 0 ;
7900 int res1 = 0 ;
7901 bool val2 ;
7902 int ecode2 = 0 ;
7903 PyObject * obj0 = 0 ;
7904 PyObject * obj1 = 0 ;
7905 char * kwnames[] = {
7906 (char *) "self",(char *) "down", NULL
7907 };
7908
7909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7911 if (!SWIG_IsOK(res1)) {
7912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7913 }
7914 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7915 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7916 if (!SWIG_IsOK(ecode2)) {
7917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7918 }
7919 arg2 = static_cast< bool >(val2);
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 (arg1)->SetMetaDown(arg2);
7923 wxPyEndAllowThreads(__tstate);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 resultobj = SWIG_Py_Void();
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7934 PyObject *obj;
7935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7936 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7937 return SWIG_Py_Void();
7938 }
7939
7940 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7941 return SWIG_Python_InitShadowInstance(args);
7942 }
7943
7944 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7945 PyObject *resultobj = 0;
7946 wxMouseState result;
7947
7948 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7949 {
7950 PyThreadState* __tstate = wxPyBeginAllowThreads();
7951 result = wxGetMouseState();
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7963 PyObject *resultobj = 0;
7964
7965 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7966 {
7967 if (!wxPyCheckForApp()) SWIG_fail;
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 wxWakeUpMainThread();
7970 wxPyEndAllowThreads(__tstate);
7971 if (PyErr_Occurred()) SWIG_fail;
7972 }
7973 resultobj = SWIG_Py_Void();
7974 return resultobj;
7975 fail:
7976 return NULL;
7977 }
7978
7979
7980 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7981 PyObject *resultobj = 0;
7982
7983 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7984 {
7985 if (!wxPyCheckForApp()) SWIG_fail;
7986 PyThreadState* __tstate = wxPyBeginAllowThreads();
7987 wxMutexGuiEnter();
7988 wxPyEndAllowThreads(__tstate);
7989 if (PyErr_Occurred()) SWIG_fail;
7990 }
7991 resultobj = SWIG_Py_Void();
7992 return resultobj;
7993 fail:
7994 return NULL;
7995 }
7996
7997
7998 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7999 PyObject *resultobj = 0;
8000
8001 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8002 {
8003 if (!wxPyCheckForApp()) SWIG_fail;
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 wxMutexGuiLeave();
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *resultobj = 0;
8018 wxMutexGuiLocker *result = 0 ;
8019
8020 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8021 {
8022 if (!wxPyCheckForApp()) SWIG_fail;
8023 PyThreadState* __tstate = wxPyBeginAllowThreads();
8024 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8025 wxPyEndAllowThreads(__tstate);
8026 if (PyErr_Occurred()) SWIG_fail;
8027 }
8028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8029 return resultobj;
8030 fail:
8031 return NULL;
8032 }
8033
8034
8035 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8036 PyObject *resultobj = 0;
8037 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8038 void *argp1 = 0 ;
8039 int res1 = 0 ;
8040 PyObject *swig_obj[1] ;
8041
8042 if (!args) SWIG_fail;
8043 swig_obj[0] = args;
8044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8045 if (!SWIG_IsOK(res1)) {
8046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8047 }
8048 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 delete arg1;
8052
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 resultobj = SWIG_Py_Void();
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8064 PyObject *obj;
8065 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8066 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8067 return SWIG_Py_Void();
8068 }
8069
8070 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8071 return SWIG_Python_InitShadowInstance(args);
8072 }
8073
8074 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8075 PyObject *resultobj = 0;
8076 bool result;
8077
8078 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8079 {
8080 PyThreadState* __tstate = wxPyBeginAllowThreads();
8081 result = (bool)wxThread_IsMain();
8082 wxPyEndAllowThreads(__tstate);
8083 if (PyErr_Occurred()) SWIG_fail;
8084 }
8085 {
8086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8087 }
8088 return resultobj;
8089 fail:
8090 return NULL;
8091 }
8092
8093
8094 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8095 PyObject *resultobj = 0;
8096 wxString *arg1 = 0 ;
8097 wxToolTip *result = 0 ;
8098 bool temp1 = false ;
8099 PyObject * obj0 = 0 ;
8100 char * kwnames[] = {
8101 (char *) "tip", NULL
8102 };
8103
8104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8105 {
8106 arg1 = wxString_in_helper(obj0);
8107 if (arg1 == NULL) SWIG_fail;
8108 temp1 = true;
8109 }
8110 {
8111 if (!wxPyCheckForApp()) SWIG_fail;
8112 PyThreadState* __tstate = wxPyBeginAllowThreads();
8113 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8118 {
8119 if (temp1)
8120 delete arg1;
8121 }
8122 return resultobj;
8123 fail:
8124 {
8125 if (temp1)
8126 delete arg1;
8127 }
8128 return NULL;
8129 }
8130
8131
8132 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8133 PyObject *resultobj = 0;
8134 wxToolTip *arg1 = (wxToolTip *) 0 ;
8135 void *argp1 = 0 ;
8136 int res1 = 0 ;
8137 PyObject *swig_obj[1] ;
8138
8139 if (!args) SWIG_fail;
8140 swig_obj[0] = args;
8141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8142 if (!SWIG_IsOK(res1)) {
8143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8144 }
8145 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8146 {
8147 PyThreadState* __tstate = wxPyBeginAllowThreads();
8148 delete arg1;
8149
8150 wxPyEndAllowThreads(__tstate);
8151 if (PyErr_Occurred()) SWIG_fail;
8152 }
8153 resultobj = SWIG_Py_Void();
8154 return resultobj;
8155 fail:
8156 return NULL;
8157 }
8158
8159
8160 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8161 PyObject *resultobj = 0;
8162 wxToolTip *arg1 = (wxToolTip *) 0 ;
8163 wxString *arg2 = 0 ;
8164 void *argp1 = 0 ;
8165 int res1 = 0 ;
8166 bool temp2 = false ;
8167 PyObject * obj0 = 0 ;
8168 PyObject * obj1 = 0 ;
8169 char * kwnames[] = {
8170 (char *) "self",(char *) "tip", NULL
8171 };
8172
8173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8175 if (!SWIG_IsOK(res1)) {
8176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8177 }
8178 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8179 {
8180 arg2 = wxString_in_helper(obj1);
8181 if (arg2 == NULL) SWIG_fail;
8182 temp2 = true;
8183 }
8184 {
8185 PyThreadState* __tstate = wxPyBeginAllowThreads();
8186 (arg1)->SetTip((wxString const &)*arg2);
8187 wxPyEndAllowThreads(__tstate);
8188 if (PyErr_Occurred()) SWIG_fail;
8189 }
8190 resultobj = SWIG_Py_Void();
8191 {
8192 if (temp2)
8193 delete arg2;
8194 }
8195 return resultobj;
8196 fail:
8197 {
8198 if (temp2)
8199 delete arg2;
8200 }
8201 return NULL;
8202 }
8203
8204
8205 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8206 PyObject *resultobj = 0;
8207 wxToolTip *arg1 = (wxToolTip *) 0 ;
8208 wxString result;
8209 void *argp1 = 0 ;
8210 int res1 = 0 ;
8211 PyObject *swig_obj[1] ;
8212
8213 if (!args) SWIG_fail;
8214 swig_obj[0] = args;
8215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8216 if (!SWIG_IsOK(res1)) {
8217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8218 }
8219 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8220 {
8221 PyThreadState* __tstate = wxPyBeginAllowThreads();
8222 result = (arg1)->GetTip();
8223 wxPyEndAllowThreads(__tstate);
8224 if (PyErr_Occurred()) SWIG_fail;
8225 }
8226 {
8227 #if wxUSE_UNICODE
8228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8229 #else
8230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8231 #endif
8232 }
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8240 PyObject *resultobj = 0;
8241 wxToolTip *arg1 = (wxToolTip *) 0 ;
8242 wxWindow *result = 0 ;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 PyObject *swig_obj[1] ;
8246
8247 if (!args) SWIG_fail;
8248 swig_obj[0] = args;
8249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8252 }
8253 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8254 {
8255 PyThreadState* __tstate = wxPyBeginAllowThreads();
8256 result = (wxWindow *)(arg1)->GetWindow();
8257 wxPyEndAllowThreads(__tstate);
8258 if (PyErr_Occurred()) SWIG_fail;
8259 }
8260 {
8261 resultobj = wxPyMake_wxObject(result, 0);
8262 }
8263 return resultobj;
8264 fail:
8265 return NULL;
8266 }
8267
8268
8269 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8270 PyObject *resultobj = 0;
8271 bool arg1 ;
8272 bool val1 ;
8273 int ecode1 = 0 ;
8274 PyObject * obj0 = 0 ;
8275 char * kwnames[] = {
8276 (char *) "flag", NULL
8277 };
8278
8279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8280 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8281 if (!SWIG_IsOK(ecode1)) {
8282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8283 }
8284 arg1 = static_cast< bool >(val1);
8285 {
8286 PyThreadState* __tstate = wxPyBeginAllowThreads();
8287 wxToolTip::Enable(arg1);
8288 wxPyEndAllowThreads(__tstate);
8289 if (PyErr_Occurred()) SWIG_fail;
8290 }
8291 resultobj = SWIG_Py_Void();
8292 return resultobj;
8293 fail:
8294 return NULL;
8295 }
8296
8297
8298 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8299 PyObject *resultobj = 0;
8300 long arg1 ;
8301 long val1 ;
8302 int ecode1 = 0 ;
8303 PyObject * obj0 = 0 ;
8304 char * kwnames[] = {
8305 (char *) "milliseconds", NULL
8306 };
8307
8308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8309 ecode1 = SWIG_AsVal_long(obj0, &val1);
8310 if (!SWIG_IsOK(ecode1)) {
8311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8312 }
8313 arg1 = static_cast< long >(val1);
8314 {
8315 PyThreadState* __tstate = wxPyBeginAllowThreads();
8316 wxToolTip::SetDelay(arg1);
8317 wxPyEndAllowThreads(__tstate);
8318 if (PyErr_Occurred()) SWIG_fail;
8319 }
8320 resultobj = SWIG_Py_Void();
8321 return resultobj;
8322 fail:
8323 return NULL;
8324 }
8325
8326
8327 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8328 PyObject *obj;
8329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8330 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8331 return SWIG_Py_Void();
8332 }
8333
8334 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8335 return SWIG_Python_InitShadowInstance(args);
8336 }
8337
8338 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8339 PyObject *resultobj = 0;
8340 wxWindow *arg1 = (wxWindow *) 0 ;
8341 wxSize *arg2 = 0 ;
8342 wxCaret *result = 0 ;
8343 void *argp1 = 0 ;
8344 int res1 = 0 ;
8345 wxSize temp2 ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 char * kwnames[] = {
8349 (char *) "window",(char *) "size", NULL
8350 };
8351
8352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8354 if (!SWIG_IsOK(res1)) {
8355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8356 }
8357 arg1 = reinterpret_cast< wxWindow * >(argp1);
8358 {
8359 arg2 = &temp2;
8360 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8361 }
8362 {
8363 if (!wxPyCheckForApp()) SWIG_fail;
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8377 PyObject *resultobj = 0;
8378 wxCaret *arg1 = (wxCaret *) 0 ;
8379 void *argp1 = 0 ;
8380 int res1 = 0 ;
8381 PyObject *swig_obj[1] ;
8382
8383 if (!args) SWIG_fail;
8384 swig_obj[0] = args;
8385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8386 if (!SWIG_IsOK(res1)) {
8387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8388 }
8389 arg1 = reinterpret_cast< wxCaret * >(argp1);
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 delete arg1;
8393
8394 wxPyEndAllowThreads(__tstate);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 resultobj = SWIG_Py_Void();
8398 return resultobj;
8399 fail:
8400 return NULL;
8401 }
8402
8403
8404 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8405 PyObject *resultobj = 0;
8406 wxCaret *arg1 = (wxCaret *) 0 ;
8407 void *argp1 = 0 ;
8408 int res1 = 0 ;
8409 PyObject *swig_obj[1] ;
8410
8411 if (!args) SWIG_fail;
8412 swig_obj[0] = args;
8413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8416 }
8417 arg1 = reinterpret_cast< wxCaret * >(argp1);
8418 {
8419 PyThreadState* __tstate = wxPyBeginAllowThreads();
8420 wxCaret_Destroy(arg1);
8421 wxPyEndAllowThreads(__tstate);
8422 if (PyErr_Occurred()) SWIG_fail;
8423 }
8424 resultobj = SWIG_Py_Void();
8425 return resultobj;
8426 fail:
8427 return NULL;
8428 }
8429
8430
8431 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8432 PyObject *resultobj = 0;
8433 wxCaret *arg1 = (wxCaret *) 0 ;
8434 bool result;
8435 void *argp1 = 0 ;
8436 int res1 = 0 ;
8437 PyObject *swig_obj[1] ;
8438
8439 if (!args) SWIG_fail;
8440 swig_obj[0] = args;
8441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8442 if (!SWIG_IsOK(res1)) {
8443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8444 }
8445 arg1 = reinterpret_cast< wxCaret * >(argp1);
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (bool)(arg1)->IsOk();
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 {
8453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8454 }
8455 return resultobj;
8456 fail:
8457 return NULL;
8458 }
8459
8460
8461 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8462 PyObject *resultobj = 0;
8463 wxCaret *arg1 = (wxCaret *) 0 ;
8464 bool result;
8465 void *argp1 = 0 ;
8466 int res1 = 0 ;
8467 PyObject *swig_obj[1] ;
8468
8469 if (!args) SWIG_fail;
8470 swig_obj[0] = args;
8471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8474 }
8475 arg1 = reinterpret_cast< wxCaret * >(argp1);
8476 {
8477 PyThreadState* __tstate = wxPyBeginAllowThreads();
8478 result = (bool)(arg1)->IsVisible();
8479 wxPyEndAllowThreads(__tstate);
8480 if (PyErr_Occurred()) SWIG_fail;
8481 }
8482 {
8483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8484 }
8485 return resultobj;
8486 fail:
8487 return NULL;
8488 }
8489
8490
8491 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8492 PyObject *resultobj = 0;
8493 wxCaret *arg1 = (wxCaret *) 0 ;
8494 wxPoint result;
8495 void *argp1 = 0 ;
8496 int res1 = 0 ;
8497 PyObject *swig_obj[1] ;
8498
8499 if (!args) SWIG_fail;
8500 swig_obj[0] = args;
8501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8502 if (!SWIG_IsOK(res1)) {
8503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8504 }
8505 arg1 = reinterpret_cast< wxCaret * >(argp1);
8506 {
8507 PyThreadState* __tstate = wxPyBeginAllowThreads();
8508 result = (arg1)->GetPosition();
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8513 return resultobj;
8514 fail:
8515 return NULL;
8516 }
8517
8518
8519 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8520 PyObject *resultobj = 0;
8521 wxCaret *arg1 = (wxCaret *) 0 ;
8522 int *arg2 = (int *) 0 ;
8523 int *arg3 = (int *) 0 ;
8524 void *argp1 = 0 ;
8525 int res1 = 0 ;
8526 int temp2 ;
8527 int res2 = SWIG_TMPOBJ ;
8528 int temp3 ;
8529 int res3 = SWIG_TMPOBJ ;
8530 PyObject *swig_obj[1] ;
8531
8532 arg2 = &temp2;
8533 arg3 = &temp3;
8534 if (!args) SWIG_fail;
8535 swig_obj[0] = args;
8536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8537 if (!SWIG_IsOK(res1)) {
8538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8539 }
8540 arg1 = reinterpret_cast< wxCaret * >(argp1);
8541 {
8542 PyThreadState* __tstate = wxPyBeginAllowThreads();
8543 (arg1)->GetPosition(arg2,arg3);
8544 wxPyEndAllowThreads(__tstate);
8545 if (PyErr_Occurred()) SWIG_fail;
8546 }
8547 resultobj = SWIG_Py_Void();
8548 if (SWIG_IsTmpObj(res2)) {
8549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8550 } else {
8551 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8552 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8553 }
8554 if (SWIG_IsTmpObj(res3)) {
8555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8556 } else {
8557 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8559 }
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8567 PyObject *resultobj = 0;
8568 wxCaret *arg1 = (wxCaret *) 0 ;
8569 wxSize result;
8570 void *argp1 = 0 ;
8571 int res1 = 0 ;
8572 PyObject *swig_obj[1] ;
8573
8574 if (!args) SWIG_fail;
8575 swig_obj[0] = args;
8576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8577 if (!SWIG_IsOK(res1)) {
8578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8579 }
8580 arg1 = reinterpret_cast< wxCaret * >(argp1);
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (arg1)->GetSize();
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8588 return resultobj;
8589 fail:
8590 return NULL;
8591 }
8592
8593
8594 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8595 PyObject *resultobj = 0;
8596 wxCaret *arg1 = (wxCaret *) 0 ;
8597 int *arg2 = (int *) 0 ;
8598 int *arg3 = (int *) 0 ;
8599 void *argp1 = 0 ;
8600 int res1 = 0 ;
8601 int temp2 ;
8602 int res2 = SWIG_TMPOBJ ;
8603 int temp3 ;
8604 int res3 = SWIG_TMPOBJ ;
8605 PyObject *swig_obj[1] ;
8606
8607 arg2 = &temp2;
8608 arg3 = &temp3;
8609 if (!args) SWIG_fail;
8610 swig_obj[0] = args;
8611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8614 }
8615 arg1 = reinterpret_cast< wxCaret * >(argp1);
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 (arg1)->GetSize(arg2,arg3);
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 resultobj = SWIG_Py_Void();
8623 if (SWIG_IsTmpObj(res2)) {
8624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8625 } else {
8626 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8628 }
8629 if (SWIG_IsTmpObj(res3)) {
8630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8631 } else {
8632 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8634 }
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8642 PyObject *resultobj = 0;
8643 wxCaret *arg1 = (wxCaret *) 0 ;
8644 wxWindow *result = 0 ;
8645 void *argp1 = 0 ;
8646 int res1 = 0 ;
8647 PyObject *swig_obj[1] ;
8648
8649 if (!args) SWIG_fail;
8650 swig_obj[0] = args;
8651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8652 if (!SWIG_IsOK(res1)) {
8653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8654 }
8655 arg1 = reinterpret_cast< wxCaret * >(argp1);
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (wxWindow *)(arg1)->GetWindow();
8659 wxPyEndAllowThreads(__tstate);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 {
8663 resultobj = wxPyMake_wxObject(result, 0);
8664 }
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj = 0;
8673 wxCaret *arg1 = (wxCaret *) 0 ;
8674 int arg2 ;
8675 int arg3 ;
8676 void *argp1 = 0 ;
8677 int res1 = 0 ;
8678 int val2 ;
8679 int ecode2 = 0 ;
8680 int val3 ;
8681 int ecode3 = 0 ;
8682 PyObject * obj0 = 0 ;
8683 PyObject * obj1 = 0 ;
8684 PyObject * obj2 = 0 ;
8685 char * kwnames[] = {
8686 (char *) "self",(char *) "x",(char *) "y", NULL
8687 };
8688
8689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8693 }
8694 arg1 = reinterpret_cast< wxCaret * >(argp1);
8695 ecode2 = SWIG_AsVal_int(obj1, &val2);
8696 if (!SWIG_IsOK(ecode2)) {
8697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8698 }
8699 arg2 = static_cast< int >(val2);
8700 ecode3 = SWIG_AsVal_int(obj2, &val3);
8701 if (!SWIG_IsOK(ecode3)) {
8702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8703 }
8704 arg3 = static_cast< int >(val3);
8705 {
8706 PyThreadState* __tstate = wxPyBeginAllowThreads();
8707 (arg1)->Move(arg2,arg3);
8708 wxPyEndAllowThreads(__tstate);
8709 if (PyErr_Occurred()) SWIG_fail;
8710 }
8711 resultobj = SWIG_Py_Void();
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj = 0;
8720 wxCaret *arg1 = (wxCaret *) 0 ;
8721 wxPoint *arg2 = 0 ;
8722 void *argp1 = 0 ;
8723 int res1 = 0 ;
8724 wxPoint temp2 ;
8725 PyObject * obj0 = 0 ;
8726 PyObject * obj1 = 0 ;
8727 char * kwnames[] = {
8728 (char *) "self",(char *) "pt", NULL
8729 };
8730
8731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8733 if (!SWIG_IsOK(res1)) {
8734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8735 }
8736 arg1 = reinterpret_cast< wxCaret * >(argp1);
8737 {
8738 arg2 = &temp2;
8739 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8740 }
8741 {
8742 PyThreadState* __tstate = wxPyBeginAllowThreads();
8743 (arg1)->Move((wxPoint const &)*arg2);
8744 wxPyEndAllowThreads(__tstate);
8745 if (PyErr_Occurred()) SWIG_fail;
8746 }
8747 resultobj = SWIG_Py_Void();
8748 return resultobj;
8749 fail:
8750 return NULL;
8751 }
8752
8753
8754 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj = 0;
8756 wxCaret *arg1 = (wxCaret *) 0 ;
8757 int arg2 ;
8758 int arg3 ;
8759 void *argp1 = 0 ;
8760 int res1 = 0 ;
8761 int val2 ;
8762 int ecode2 = 0 ;
8763 int val3 ;
8764 int ecode3 = 0 ;
8765 PyObject * obj0 = 0 ;
8766 PyObject * obj1 = 0 ;
8767 PyObject * obj2 = 0 ;
8768 char * kwnames[] = {
8769 (char *) "self",(char *) "width",(char *) "height", NULL
8770 };
8771
8772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8776 }
8777 arg1 = reinterpret_cast< wxCaret * >(argp1);
8778 ecode2 = SWIG_AsVal_int(obj1, &val2);
8779 if (!SWIG_IsOK(ecode2)) {
8780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8781 }
8782 arg2 = static_cast< int >(val2);
8783 ecode3 = SWIG_AsVal_int(obj2, &val3);
8784 if (!SWIG_IsOK(ecode3)) {
8785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8786 }
8787 arg3 = static_cast< int >(val3);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 (arg1)->SetSize(arg2,arg3);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 resultobj = SWIG_Py_Void();
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8802 PyObject *resultobj = 0;
8803 wxCaret *arg1 = (wxCaret *) 0 ;
8804 wxSize *arg2 = 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 wxSize temp2 ;
8808 PyObject * obj0 = 0 ;
8809 PyObject * obj1 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "size", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8818 }
8819 arg1 = reinterpret_cast< wxCaret * >(argp1);
8820 {
8821 arg2 = &temp2;
8822 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8823 }
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 (arg1)->SetSize((wxSize const &)*arg2);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_Py_Void();
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj = 0;
8839 wxCaret *arg1 = (wxCaret *) 0 ;
8840 int arg2 = (int) true ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 int val2 ;
8844 int ecode2 = 0 ;
8845 PyObject * obj0 = 0 ;
8846 PyObject * obj1 = 0 ;
8847 char * kwnames[] = {
8848 (char *) "self",(char *) "show", NULL
8849 };
8850
8851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8853 if (!SWIG_IsOK(res1)) {
8854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8855 }
8856 arg1 = reinterpret_cast< wxCaret * >(argp1);
8857 if (obj1) {
8858 ecode2 = SWIG_AsVal_int(obj1, &val2);
8859 if (!SWIG_IsOK(ecode2)) {
8860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8861 }
8862 arg2 = static_cast< int >(val2);
8863 }
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 (arg1)->Show(arg2);
8867 wxPyEndAllowThreads(__tstate);
8868 if (PyErr_Occurred()) SWIG_fail;
8869 }
8870 resultobj = SWIG_Py_Void();
8871 return resultobj;
8872 fail:
8873 return NULL;
8874 }
8875
8876
8877 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8878 PyObject *resultobj = 0;
8879 wxCaret *arg1 = (wxCaret *) 0 ;
8880 void *argp1 = 0 ;
8881 int res1 = 0 ;
8882 PyObject *swig_obj[1] ;
8883
8884 if (!args) SWIG_fail;
8885 swig_obj[0] = args;
8886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8889 }
8890 arg1 = reinterpret_cast< wxCaret * >(argp1);
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 (arg1)->Hide();
8894 wxPyEndAllowThreads(__tstate);
8895 if (PyErr_Occurred()) SWIG_fail;
8896 }
8897 resultobj = SWIG_Py_Void();
8898 return resultobj;
8899 fail:
8900 return NULL;
8901 }
8902
8903
8904 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8905 PyObject *resultobj = 0;
8906 int result;
8907
8908 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8909 {
8910 PyThreadState* __tstate = wxPyBeginAllowThreads();
8911 result = (int)wxCaret::GetBlinkTime();
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 resultobj = SWIG_From_int(static_cast< int >(result));
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8923 PyObject *resultobj = 0;
8924 int arg1 ;
8925 int val1 ;
8926 int ecode1 = 0 ;
8927 PyObject * obj0 = 0 ;
8928 char * kwnames[] = {
8929 (char *) "milliseconds", NULL
8930 };
8931
8932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8933 ecode1 = SWIG_AsVal_int(obj0, &val1);
8934 if (!SWIG_IsOK(ecode1)) {
8935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8936 }
8937 arg1 = static_cast< int >(val1);
8938 {
8939 PyThreadState* __tstate = wxPyBeginAllowThreads();
8940 wxCaret::SetBlinkTime(arg1);
8941 wxPyEndAllowThreads(__tstate);
8942 if (PyErr_Occurred()) SWIG_fail;
8943 }
8944 resultobj = SWIG_Py_Void();
8945 return resultobj;
8946 fail:
8947 return NULL;
8948 }
8949
8950
8951 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8952 PyObject *obj;
8953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8954 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8955 return SWIG_Py_Void();
8956 }
8957
8958 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8959 return SWIG_Python_InitShadowInstance(args);
8960 }
8961
8962 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8963 PyObject *resultobj = 0;
8964 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8965 wxBusyCursor *result = 0 ;
8966 void *argp1 = 0 ;
8967 int res1 = 0 ;
8968 PyObject * obj0 = 0 ;
8969 char * kwnames[] = {
8970 (char *) "cursor", NULL
8971 };
8972
8973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8974 if (obj0) {
8975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8976 if (!SWIG_IsOK(res1)) {
8977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8978 }
8979 arg1 = reinterpret_cast< wxCursor * >(argp1);
8980 }
8981 {
8982 if (!wxPyCheckForApp()) SWIG_fail;
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8985 wxPyEndAllowThreads(__tstate);
8986 if (PyErr_Occurred()) SWIG_fail;
8987 }
8988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8998 void *argp1 = 0 ;
8999 int res1 = 0 ;
9000 PyObject *swig_obj[1] ;
9001
9002 if (!args) SWIG_fail;
9003 swig_obj[0] = args;
9004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9005 if (!SWIG_IsOK(res1)) {
9006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9007 }
9008 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 delete arg1;
9012
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 resultobj = SWIG_Py_Void();
9017 return resultobj;
9018 fail:
9019 return NULL;
9020 }
9021
9022
9023 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9024 PyObject *obj;
9025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9026 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9027 return SWIG_Py_Void();
9028 }
9029
9030 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9031 return SWIG_Python_InitShadowInstance(args);
9032 }
9033
9034 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9035 PyObject *resultobj = 0;
9036 wxWindow *arg1 = (wxWindow *) NULL ;
9037 wxWindowDisabler *result = 0 ;
9038 void *argp1 = 0 ;
9039 int res1 = 0 ;
9040 PyObject * obj0 = 0 ;
9041 char * kwnames[] = {
9042 (char *) "winToSkip", NULL
9043 };
9044
9045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9046 if (obj0) {
9047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9048 if (!SWIG_IsOK(res1)) {
9049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9050 }
9051 arg1 = reinterpret_cast< wxWindow * >(argp1);
9052 }
9053 {
9054 if (!wxPyCheckForApp()) SWIG_fail;
9055 PyThreadState* __tstate = wxPyBeginAllowThreads();
9056 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9057 wxPyEndAllowThreads(__tstate);
9058 if (PyErr_Occurred()) SWIG_fail;
9059 }
9060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9061 return resultobj;
9062 fail:
9063 return NULL;
9064 }
9065
9066
9067 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9068 PyObject *resultobj = 0;
9069 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9070 void *argp1 = 0 ;
9071 int res1 = 0 ;
9072 PyObject *swig_obj[1] ;
9073
9074 if (!args) SWIG_fail;
9075 swig_obj[0] = args;
9076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9077 if (!SWIG_IsOK(res1)) {
9078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9079 }
9080 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9081 {
9082 PyThreadState* __tstate = wxPyBeginAllowThreads();
9083 delete arg1;
9084
9085 wxPyEndAllowThreads(__tstate);
9086 if (PyErr_Occurred()) SWIG_fail;
9087 }
9088 resultobj = SWIG_Py_Void();
9089 return resultobj;
9090 fail:
9091 return NULL;
9092 }
9093
9094
9095 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9096 PyObject *obj;
9097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9098 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9099 return SWIG_Py_Void();
9100 }
9101
9102 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 return SWIG_Python_InitShadowInstance(args);
9104 }
9105
9106 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9107 PyObject *resultobj = 0;
9108 wxString *arg1 = 0 ;
9109 wxBusyInfo *result = 0 ;
9110 bool temp1 = false ;
9111 PyObject * obj0 = 0 ;
9112 char * kwnames[] = {
9113 (char *) "message", NULL
9114 };
9115
9116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9117 {
9118 arg1 = wxString_in_helper(obj0);
9119 if (arg1 == NULL) SWIG_fail;
9120 temp1 = true;
9121 }
9122 {
9123 if (!wxPyCheckForApp()) SWIG_fail;
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9130 {
9131 if (temp1)
9132 delete arg1;
9133 }
9134 return resultobj;
9135 fail:
9136 {
9137 if (temp1)
9138 delete arg1;
9139 }
9140 return NULL;
9141 }
9142
9143
9144 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9145 PyObject *resultobj = 0;
9146 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 PyObject *swig_obj[1] ;
9150
9151 if (!args) SWIG_fail;
9152 swig_obj[0] = args;
9153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9154 if (!SWIG_IsOK(res1)) {
9155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9156 }
9157 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9158 {
9159 PyThreadState* __tstate = wxPyBeginAllowThreads();
9160 delete arg1;
9161
9162 wxPyEndAllowThreads(__tstate);
9163 if (PyErr_Occurred()) SWIG_fail;
9164 }
9165 resultobj = SWIG_Py_Void();
9166 return resultobj;
9167 fail:
9168 return NULL;
9169 }
9170
9171
9172 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9173 PyObject *obj;
9174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9175 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9176 return SWIG_Py_Void();
9177 }
9178
9179 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9180 return SWIG_Python_InitShadowInstance(args);
9181 }
9182
9183 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9184 PyObject *resultobj = 0;
9185 wxStopWatch *result = 0 ;
9186
9187 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9188 {
9189 PyThreadState* __tstate = wxPyBeginAllowThreads();
9190 result = (wxStopWatch *)new wxStopWatch();
9191 wxPyEndAllowThreads(__tstate);
9192 if (PyErr_Occurred()) SWIG_fail;
9193 }
9194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj = 0;
9203 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9204 long arg2 = (long) 0 ;
9205 void *argp1 = 0 ;
9206 int res1 = 0 ;
9207 long val2 ;
9208 int ecode2 = 0 ;
9209 PyObject * obj0 = 0 ;
9210 PyObject * obj1 = 0 ;
9211 char * kwnames[] = {
9212 (char *) "self",(char *) "t0", NULL
9213 };
9214
9215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9217 if (!SWIG_IsOK(res1)) {
9218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9219 }
9220 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9221 if (obj1) {
9222 ecode2 = SWIG_AsVal_long(obj1, &val2);
9223 if (!SWIG_IsOK(ecode2)) {
9224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9225 }
9226 arg2 = static_cast< long >(val2);
9227 }
9228 {
9229 PyThreadState* __tstate = wxPyBeginAllowThreads();
9230 (arg1)->Start(arg2);
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 resultobj = SWIG_Py_Void();
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9242 PyObject *resultobj = 0;
9243 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9244 void *argp1 = 0 ;
9245 int res1 = 0 ;
9246 PyObject *swig_obj[1] ;
9247
9248 if (!args) SWIG_fail;
9249 swig_obj[0] = args;
9250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9251 if (!SWIG_IsOK(res1)) {
9252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9253 }
9254 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 (arg1)->Pause();
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 resultobj = SWIG_Py_Void();
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9269 PyObject *resultobj = 0;
9270 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9271 void *argp1 = 0 ;
9272 int res1 = 0 ;
9273 PyObject *swig_obj[1] ;
9274
9275 if (!args) SWIG_fail;
9276 swig_obj[0] = args;
9277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9278 if (!SWIG_IsOK(res1)) {
9279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9280 }
9281 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 (arg1)->Resume();
9285 wxPyEndAllowThreads(__tstate);
9286 if (PyErr_Occurred()) SWIG_fail;
9287 }
9288 resultobj = SWIG_Py_Void();
9289 return resultobj;
9290 fail:
9291 return NULL;
9292 }
9293
9294
9295 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9296 PyObject *resultobj = 0;
9297 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9298 long result;
9299 void *argp1 = 0 ;
9300 int res1 = 0 ;
9301 PyObject *swig_obj[1] ;
9302
9303 if (!args) SWIG_fail;
9304 swig_obj[0] = args;
9305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9306 if (!SWIG_IsOK(res1)) {
9307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9308 }
9309 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9310 {
9311 PyThreadState* __tstate = wxPyBeginAllowThreads();
9312 result = (long)((wxStopWatch const *)arg1)->Time();
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 resultobj = SWIG_From_long(static_cast< long >(result));
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9324 PyObject *obj;
9325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9326 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9327 return SWIG_Py_Void();
9328 }
9329
9330 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9331 return SWIG_Python_InitShadowInstance(args);
9332 }
9333
9334 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9335 PyObject *resultobj = 0;
9336 int arg1 = (int) 9 ;
9337 int arg2 = (int) wxID_FILE1 ;
9338 wxFileHistory *result = 0 ;
9339 int val1 ;
9340 int ecode1 = 0 ;
9341 int val2 ;
9342 int ecode2 = 0 ;
9343 PyObject * obj0 = 0 ;
9344 PyObject * obj1 = 0 ;
9345 char * kwnames[] = {
9346 (char *) "maxFiles",(char *) "idBase", NULL
9347 };
9348
9349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9350 if (obj0) {
9351 ecode1 = SWIG_AsVal_int(obj0, &val1);
9352 if (!SWIG_IsOK(ecode1)) {
9353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9354 }
9355 arg1 = static_cast< int >(val1);
9356 }
9357 if (obj1) {
9358 ecode2 = SWIG_AsVal_int(obj1, &val2);
9359 if (!SWIG_IsOK(ecode2)) {
9360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9361 }
9362 arg2 = static_cast< int >(val2);
9363 }
9364 {
9365 PyThreadState* __tstate = wxPyBeginAllowThreads();
9366 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9371 return resultobj;
9372 fail:
9373 return NULL;
9374 }
9375
9376
9377 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9378 PyObject *resultobj = 0;
9379 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9380 void *argp1 = 0 ;
9381 int res1 = 0 ;
9382 PyObject *swig_obj[1] ;
9383
9384 if (!args) SWIG_fail;
9385 swig_obj[0] = args;
9386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9387 if (!SWIG_IsOK(res1)) {
9388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9389 }
9390 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9391 {
9392 PyThreadState* __tstate = wxPyBeginAllowThreads();
9393 delete arg1;
9394
9395 wxPyEndAllowThreads(__tstate);
9396 if (PyErr_Occurred()) SWIG_fail;
9397 }
9398 resultobj = SWIG_Py_Void();
9399 return resultobj;
9400 fail:
9401 return NULL;
9402 }
9403
9404
9405 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9406 PyObject *resultobj = 0;
9407 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9408 wxString *arg2 = 0 ;
9409 void *argp1 = 0 ;
9410 int res1 = 0 ;
9411 bool temp2 = false ;
9412 PyObject * obj0 = 0 ;
9413 PyObject * obj1 = 0 ;
9414 char * kwnames[] = {
9415 (char *) "self",(char *) "file", NULL
9416 };
9417
9418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9420 if (!SWIG_IsOK(res1)) {
9421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9422 }
9423 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9424 {
9425 arg2 = wxString_in_helper(obj1);
9426 if (arg2 == NULL) SWIG_fail;
9427 temp2 = true;
9428 }
9429 {
9430 PyThreadState* __tstate = wxPyBeginAllowThreads();
9431 (arg1)->AddFileToHistory((wxString const &)*arg2);
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 resultobj = SWIG_Py_Void();
9436 {
9437 if (temp2)
9438 delete arg2;
9439 }
9440 return resultobj;
9441 fail:
9442 {
9443 if (temp2)
9444 delete arg2;
9445 }
9446 return NULL;
9447 }
9448
9449
9450 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj = 0;
9452 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9453 int arg2 ;
9454 void *argp1 = 0 ;
9455 int res1 = 0 ;
9456 int val2 ;
9457 int ecode2 = 0 ;
9458 PyObject * obj0 = 0 ;
9459 PyObject * obj1 = 0 ;
9460 char * kwnames[] = {
9461 (char *) "self",(char *) "i", NULL
9462 };
9463
9464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9466 if (!SWIG_IsOK(res1)) {
9467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9468 }
9469 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9470 ecode2 = SWIG_AsVal_int(obj1, &val2);
9471 if (!SWIG_IsOK(ecode2)) {
9472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9473 }
9474 arg2 = static_cast< int >(val2);
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 (arg1)->RemoveFileFromHistory(arg2);
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_Py_Void();
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9489 PyObject *resultobj = 0;
9490 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9491 int result;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 PyObject *swig_obj[1] ;
9495
9496 if (!args) SWIG_fail;
9497 swig_obj[0] = args;
9498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9499 if (!SWIG_IsOK(res1)) {
9500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9501 }
9502 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9503 {
9504 PyThreadState* __tstate = wxPyBeginAllowThreads();
9505 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_From_int(static_cast< int >(result));
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj = 0;
9518 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9519 wxMenu *arg2 = (wxMenu *) 0 ;
9520 void *argp1 = 0 ;
9521 int res1 = 0 ;
9522 void *argp2 = 0 ;
9523 int res2 = 0 ;
9524 PyObject * obj0 = 0 ;
9525 PyObject * obj1 = 0 ;
9526 char * kwnames[] = {
9527 (char *) "self",(char *) "menu", NULL
9528 };
9529
9530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9534 }
9535 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9537 if (!SWIG_IsOK(res2)) {
9538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9539 }
9540 arg2 = reinterpret_cast< wxMenu * >(argp2);
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 (arg1)->UseMenu(arg2);
9544 wxPyEndAllowThreads(__tstate);
9545 if (PyErr_Occurred()) SWIG_fail;
9546 }
9547 resultobj = SWIG_Py_Void();
9548 return resultobj;
9549 fail:
9550 return NULL;
9551 }
9552
9553
9554 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9555 PyObject *resultobj = 0;
9556 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9557 wxMenu *arg2 = (wxMenu *) 0 ;
9558 void *argp1 = 0 ;
9559 int res1 = 0 ;
9560 void *argp2 = 0 ;
9561 int res2 = 0 ;
9562 PyObject * obj0 = 0 ;
9563 PyObject * obj1 = 0 ;
9564 char * kwnames[] = {
9565 (char *) "self",(char *) "menu", NULL
9566 };
9567
9568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9570 if (!SWIG_IsOK(res1)) {
9571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9572 }
9573 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9575 if (!SWIG_IsOK(res2)) {
9576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9577 }
9578 arg2 = reinterpret_cast< wxMenu * >(argp2);
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 (arg1)->RemoveMenu(arg2);
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 resultobj = SWIG_Py_Void();
9586 return resultobj;
9587 fail:
9588 return NULL;
9589 }
9590
9591
9592 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9593 PyObject *resultobj = 0;
9594 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9595 wxConfigBase *arg2 = 0 ;
9596 void *argp1 = 0 ;
9597 int res1 = 0 ;
9598 void *argp2 = 0 ;
9599 int res2 = 0 ;
9600 PyObject * obj0 = 0 ;
9601 PyObject * obj1 = 0 ;
9602 char * kwnames[] = {
9603 (char *) "self",(char *) "config", NULL
9604 };
9605
9606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9608 if (!SWIG_IsOK(res1)) {
9609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9610 }
9611 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9612 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9613 if (!SWIG_IsOK(res2)) {
9614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9615 }
9616 if (!argp2) {
9617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9618 }
9619 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9620 {
9621 PyThreadState* __tstate = wxPyBeginAllowThreads();
9622 (arg1)->Load(*arg2);
9623 wxPyEndAllowThreads(__tstate);
9624 if (PyErr_Occurred()) SWIG_fail;
9625 }
9626 resultobj = SWIG_Py_Void();
9627 return resultobj;
9628 fail:
9629 return NULL;
9630 }
9631
9632
9633 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj = 0;
9635 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9636 wxConfigBase *arg2 = 0 ;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 void *argp2 = 0 ;
9640 int res2 = 0 ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 char * kwnames[] = {
9644 (char *) "self",(char *) "config", NULL
9645 };
9646
9647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9649 if (!SWIG_IsOK(res1)) {
9650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9651 }
9652 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9653 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9654 if (!SWIG_IsOK(res2)) {
9655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9656 }
9657 if (!argp2) {
9658 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9659 }
9660 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 (arg1)->Save(*arg2);
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 resultobj = SWIG_Py_Void();
9668 return resultobj;
9669 fail:
9670 return NULL;
9671 }
9672
9673
9674 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9675 PyObject *resultobj = 0;
9676 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9677 void *argp1 = 0 ;
9678 int res1 = 0 ;
9679 PyObject *swig_obj[1] ;
9680
9681 if (!args) SWIG_fail;
9682 swig_obj[0] = args;
9683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9684 if (!SWIG_IsOK(res1)) {
9685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9686 }
9687 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9688 {
9689 PyThreadState* __tstate = wxPyBeginAllowThreads();
9690 (arg1)->AddFilesToMenu();
9691 wxPyEndAllowThreads(__tstate);
9692 if (PyErr_Occurred()) SWIG_fail;
9693 }
9694 resultobj = SWIG_Py_Void();
9695 return resultobj;
9696 fail:
9697 return NULL;
9698 }
9699
9700
9701 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9704 wxMenu *arg2 = (wxMenu *) 0 ;
9705 void *argp1 = 0 ;
9706 int res1 = 0 ;
9707 void *argp2 = 0 ;
9708 int res2 = 0 ;
9709 PyObject * obj0 = 0 ;
9710 PyObject * obj1 = 0 ;
9711 char * kwnames[] = {
9712 (char *) "self",(char *) "menu", NULL
9713 };
9714
9715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9717 if (!SWIG_IsOK(res1)) {
9718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9719 }
9720 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9722 if (!SWIG_IsOK(res2)) {
9723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9724 }
9725 arg2 = reinterpret_cast< wxMenu * >(argp2);
9726 {
9727 PyThreadState* __tstate = wxPyBeginAllowThreads();
9728 (arg1)->AddFilesToMenu(arg2);
9729 wxPyEndAllowThreads(__tstate);
9730 if (PyErr_Occurred()) SWIG_fail;
9731 }
9732 resultobj = SWIG_Py_Void();
9733 return resultobj;
9734 fail:
9735 return NULL;
9736 }
9737
9738
9739 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9740 PyObject *resultobj = 0;
9741 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9742 int arg2 ;
9743 wxString result;
9744 void *argp1 = 0 ;
9745 int res1 = 0 ;
9746 int val2 ;
9747 int ecode2 = 0 ;
9748 PyObject * obj0 = 0 ;
9749 PyObject * obj1 = 0 ;
9750 char * kwnames[] = {
9751 (char *) "self",(char *) "i", NULL
9752 };
9753
9754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9756 if (!SWIG_IsOK(res1)) {
9757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9758 }
9759 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9760 ecode2 = SWIG_AsVal_int(obj1, &val2);
9761 if (!SWIG_IsOK(ecode2)) {
9762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9763 }
9764 arg2 = static_cast< int >(val2);
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 {
9772 #if wxUSE_UNICODE
9773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9774 #else
9775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9776 #endif
9777 }
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9785 PyObject *resultobj = 0;
9786 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9787 int result;
9788 void *argp1 = 0 ;
9789 int res1 = 0 ;
9790 PyObject *swig_obj[1] ;
9791
9792 if (!args) SWIG_fail;
9793 swig_obj[0] = args;
9794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9795 if (!SWIG_IsOK(res1)) {
9796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9797 }
9798 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 result = (int)((wxFileHistory const *)arg1)->GetCount();
9802 wxPyEndAllowThreads(__tstate);
9803 if (PyErr_Occurred()) SWIG_fail;
9804 }
9805 resultobj = SWIG_From_int(static_cast< int >(result));
9806 return resultobj;
9807 fail:
9808 return NULL;
9809 }
9810
9811
9812 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9813 PyObject *obj;
9814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9815 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9816 return SWIG_Py_Void();
9817 }
9818
9819 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9820 return SWIG_Python_InitShadowInstance(args);
9821 }
9822
9823 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9824 PyObject *resultobj = 0;
9825 wxString *arg1 = 0 ;
9826 wxString const &arg2_defvalue = wxPyEmptyString ;
9827 wxString *arg2 = (wxString *) &arg2_defvalue ;
9828 wxSingleInstanceChecker *result = 0 ;
9829 bool temp1 = false ;
9830 bool temp2 = false ;
9831 PyObject * obj0 = 0 ;
9832 PyObject * obj1 = 0 ;
9833 char * kwnames[] = {
9834 (char *) "name",(char *) "path", NULL
9835 };
9836
9837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9838 {
9839 arg1 = wxString_in_helper(obj0);
9840 if (arg1 == NULL) SWIG_fail;
9841 temp1 = true;
9842 }
9843 if (obj1) {
9844 {
9845 arg2 = wxString_in_helper(obj1);
9846 if (arg2 == NULL) SWIG_fail;
9847 temp2 = true;
9848 }
9849 }
9850 {
9851 PyThreadState* __tstate = wxPyBeginAllowThreads();
9852 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9857 {
9858 if (temp1)
9859 delete arg1;
9860 }
9861 {
9862 if (temp2)
9863 delete arg2;
9864 }
9865 return resultobj;
9866 fail:
9867 {
9868 if (temp1)
9869 delete arg1;
9870 }
9871 {
9872 if (temp2)
9873 delete arg2;
9874 }
9875 return NULL;
9876 }
9877
9878
9879 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9880 PyObject *resultobj = 0;
9881 wxSingleInstanceChecker *result = 0 ;
9882
9883 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9884 {
9885 PyThreadState* __tstate = wxPyBeginAllowThreads();
9886 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 PyObject *resultobj = 0;
9899 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9900 void *argp1 = 0 ;
9901 int res1 = 0 ;
9902 PyObject *swig_obj[1] ;
9903
9904 if (!args) SWIG_fail;
9905 swig_obj[0] = args;
9906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9909 }
9910 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 delete arg1;
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 resultobj = SWIG_Py_Void();
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj = 0;
9927 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9928 wxString *arg2 = 0 ;
9929 wxString const &arg3_defvalue = wxPyEmptyString ;
9930 wxString *arg3 = (wxString *) &arg3_defvalue ;
9931 bool result;
9932 void *argp1 = 0 ;
9933 int res1 = 0 ;
9934 bool temp2 = false ;
9935 bool temp3 = false ;
9936 PyObject * obj0 = 0 ;
9937 PyObject * obj1 = 0 ;
9938 PyObject * obj2 = 0 ;
9939 char * kwnames[] = {
9940 (char *) "self",(char *) "name",(char *) "path", NULL
9941 };
9942
9943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9945 if (!SWIG_IsOK(res1)) {
9946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9947 }
9948 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9949 {
9950 arg2 = wxString_in_helper(obj1);
9951 if (arg2 == NULL) SWIG_fail;
9952 temp2 = true;
9953 }
9954 if (obj2) {
9955 {
9956 arg3 = wxString_in_helper(obj2);
9957 if (arg3 == NULL) SWIG_fail;
9958 temp3 = true;
9959 }
9960 }
9961 {
9962 PyThreadState* __tstate = wxPyBeginAllowThreads();
9963 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9964 wxPyEndAllowThreads(__tstate);
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 {
9968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9969 }
9970 {
9971 if (temp2)
9972 delete arg2;
9973 }
9974 {
9975 if (temp3)
9976 delete arg3;
9977 }
9978 return resultobj;
9979 fail:
9980 {
9981 if (temp2)
9982 delete arg2;
9983 }
9984 {
9985 if (temp3)
9986 delete arg3;
9987 }
9988 return NULL;
9989 }
9990
9991
9992 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9993 PyObject *resultobj = 0;
9994 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9995 bool result;
9996 void *argp1 = 0 ;
9997 int res1 = 0 ;
9998 PyObject *swig_obj[1] ;
9999
10000 if (!args) SWIG_fail;
10001 swig_obj[0] = args;
10002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10003 if (!SWIG_IsOK(res1)) {
10004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10005 }
10006 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10007 {
10008 PyThreadState* __tstate = wxPyBeginAllowThreads();
10009 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10010 wxPyEndAllowThreads(__tstate);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 {
10014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10015 }
10016 return resultobj;
10017 fail:
10018 return NULL;
10019 }
10020
10021
10022 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10023 PyObject *obj;
10024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10025 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10026 return SWIG_Py_Void();
10027 }
10028
10029 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10030 return SWIG_Python_InitShadowInstance(args);
10031 }
10032
10033 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10034 PyObject *resultobj = 0;
10035 wxWindow *arg1 = (wxWindow *) 0 ;
10036 wxDC *arg2 = 0 ;
10037 bool result;
10038 void *argp1 = 0 ;
10039 int res1 = 0 ;
10040 void *argp2 = 0 ;
10041 int res2 = 0 ;
10042 PyObject * obj0 = 0 ;
10043 PyObject * obj1 = 0 ;
10044 char * kwnames[] = {
10045 (char *) "window",(char *) "dc", NULL
10046 };
10047
10048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10050 if (!SWIG_IsOK(res1)) {
10051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10052 }
10053 arg1 = reinterpret_cast< wxWindow * >(argp1);
10054 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10055 if (!SWIG_IsOK(res2)) {
10056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10057 }
10058 if (!argp2) {
10059 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10060 }
10061 arg2 = reinterpret_cast< wxDC * >(argp2);
10062 {
10063 PyThreadState* __tstate = wxPyBeginAllowThreads();
10064 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10065 wxPyEndAllowThreads(__tstate);
10066 if (PyErr_Occurred()) SWIG_fail;
10067 }
10068 {
10069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10070 }
10071 return resultobj;
10072 fail:
10073 return NULL;
10074 }
10075
10076
10077 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10078 PyObject *resultobj = 0;
10079 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10080 void *argp1 = 0 ;
10081 int res1 = 0 ;
10082 PyObject *swig_obj[1] ;
10083
10084 if (!args) SWIG_fail;
10085 swig_obj[0] = args;
10086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10087 if (!SWIG_IsOK(res1)) {
10088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10089 }
10090 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 delete arg1;
10094
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 resultobj = SWIG_Py_Void();
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10106 PyObject *resultobj = 0;
10107 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10108 wxString result;
10109 void *argp1 = 0 ;
10110 int res1 = 0 ;
10111 PyObject *swig_obj[1] ;
10112
10113 if (!args) SWIG_fail;
10114 swig_obj[0] = args;
10115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10116 if (!SWIG_IsOK(res1)) {
10117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10118 }
10119 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 result = (arg1)->GetTip();
10123 wxPyEndAllowThreads(__tstate);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 {
10127 #if wxUSE_UNICODE
10128 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10129 #else
10130 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10131 #endif
10132 }
10133 return resultobj;
10134 fail:
10135 return NULL;
10136 }
10137
10138
10139 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10140 PyObject *resultobj = 0;
10141 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10142 size_t result;
10143 void *argp1 = 0 ;
10144 int res1 = 0 ;
10145 PyObject *swig_obj[1] ;
10146
10147 if (!args) SWIG_fail;
10148 swig_obj[0] = args;
10149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10150 if (!SWIG_IsOK(res1)) {
10151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10152 }
10153 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 result = (size_t)(arg1)->GetCurrentTip();
10157 wxPyEndAllowThreads(__tstate);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10161 return resultobj;
10162 fail:
10163 return NULL;
10164 }
10165
10166
10167 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10168 PyObject *resultobj = 0;
10169 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10170 wxString *arg2 = 0 ;
10171 wxString result;
10172 void *argp1 = 0 ;
10173 int res1 = 0 ;
10174 bool temp2 = false ;
10175 PyObject * obj0 = 0 ;
10176 PyObject * obj1 = 0 ;
10177 char * kwnames[] = {
10178 (char *) "self",(char *) "tip", NULL
10179 };
10180
10181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10183 if (!SWIG_IsOK(res1)) {
10184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10185 }
10186 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10187 {
10188 arg2 = wxString_in_helper(obj1);
10189 if (arg2 == NULL) SWIG_fail;
10190 temp2 = true;
10191 }
10192 {
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10195 wxPyEndAllowThreads(__tstate);
10196 if (PyErr_Occurred()) SWIG_fail;
10197 }
10198 {
10199 #if wxUSE_UNICODE
10200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10201 #else
10202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10203 #endif
10204 }
10205 {
10206 if (temp2)
10207 delete arg2;
10208 }
10209 return resultobj;
10210 fail:
10211 {
10212 if (temp2)
10213 delete arg2;
10214 }
10215 return NULL;
10216 }
10217
10218
10219 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10220 PyObject *obj;
10221 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10222 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10223 return SWIG_Py_Void();
10224 }
10225
10226 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10227 PyObject *resultobj = 0;
10228 size_t arg1 ;
10229 wxPyTipProvider *result = 0 ;
10230 size_t val1 ;
10231 int ecode1 = 0 ;
10232 PyObject * obj0 = 0 ;
10233 char * kwnames[] = {
10234 (char *) "currentTip", NULL
10235 };
10236
10237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10238 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10239 if (!SWIG_IsOK(ecode1)) {
10240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10241 }
10242 arg1 = static_cast< size_t >(val1);
10243 {
10244 PyThreadState* __tstate = wxPyBeginAllowThreads();
10245 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10246 wxPyEndAllowThreads(__tstate);
10247 if (PyErr_Occurred()) SWIG_fail;
10248 }
10249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10250 return resultobj;
10251 fail:
10252 return NULL;
10253 }
10254
10255
10256 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10257 PyObject *resultobj = 0;
10258 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10259 PyObject *arg2 = (PyObject *) 0 ;
10260 PyObject *arg3 = (PyObject *) 0 ;
10261 void *argp1 = 0 ;
10262 int res1 = 0 ;
10263 PyObject * obj0 = 0 ;
10264 PyObject * obj1 = 0 ;
10265 PyObject * obj2 = 0 ;
10266 char * kwnames[] = {
10267 (char *) "self",(char *) "self",(char *) "_class", NULL
10268 };
10269
10270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10272 if (!SWIG_IsOK(res1)) {
10273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10274 }
10275 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10276 arg2 = obj1;
10277 arg3 = obj2;
10278 {
10279 PyThreadState* __tstate = wxPyBeginAllowThreads();
10280 (arg1)->_setCallbackInfo(arg2,arg3);
10281 wxPyEndAllowThreads(__tstate);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 resultobj = SWIG_Py_Void();
10285 return resultobj;
10286 fail:
10287 return NULL;
10288 }
10289
10290
10291 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10292 PyObject *obj;
10293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10294 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10295 return SWIG_Py_Void();
10296 }
10297
10298 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10299 return SWIG_Python_InitShadowInstance(args);
10300 }
10301
10302 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxWindow *arg1 = (wxWindow *) 0 ;
10305 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10306 bool arg3 = (bool) true ;
10307 bool result;
10308 void *argp1 = 0 ;
10309 int res1 = 0 ;
10310 void *argp2 = 0 ;
10311 int res2 = 0 ;
10312 bool val3 ;
10313 int ecode3 = 0 ;
10314 PyObject * obj0 = 0 ;
10315 PyObject * obj1 = 0 ;
10316 PyObject * obj2 = 0 ;
10317 char * kwnames[] = {
10318 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10319 };
10320
10321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10323 if (!SWIG_IsOK(res1)) {
10324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10325 }
10326 arg1 = reinterpret_cast< wxWindow * >(argp1);
10327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10328 if (!SWIG_IsOK(res2)) {
10329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10330 }
10331 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10332 if (obj2) {
10333 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10334 if (!SWIG_IsOK(ecode3)) {
10335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10336 }
10337 arg3 = static_cast< bool >(val3);
10338 }
10339 {
10340 if (!wxPyCheckForApp()) SWIG_fail;
10341 PyThreadState* __tstate = wxPyBeginAllowThreads();
10342 result = (bool)wxShowTip(arg1,arg2,arg3);
10343 wxPyEndAllowThreads(__tstate);
10344 if (PyErr_Occurred()) SWIG_fail;
10345 }
10346 {
10347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10348 }
10349 return resultobj;
10350 fail:
10351 return NULL;
10352 }
10353
10354
10355 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10356 PyObject *resultobj = 0;
10357 wxString *arg1 = 0 ;
10358 size_t arg2 ;
10359 wxTipProvider *result = 0 ;
10360 bool temp1 = false ;
10361 size_t val2 ;
10362 int ecode2 = 0 ;
10363 PyObject * obj0 = 0 ;
10364 PyObject * obj1 = 0 ;
10365 char * kwnames[] = {
10366 (char *) "filename",(char *) "currentTip", NULL
10367 };
10368
10369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10370 {
10371 arg1 = wxString_in_helper(obj0);
10372 if (arg1 == NULL) SWIG_fail;
10373 temp1 = true;
10374 }
10375 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10376 if (!SWIG_IsOK(ecode2)) {
10377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10378 }
10379 arg2 = static_cast< size_t >(val2);
10380 {
10381 if (!wxPyCheckForApp()) SWIG_fail;
10382 PyThreadState* __tstate = wxPyBeginAllowThreads();
10383 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10384 wxPyEndAllowThreads(__tstate);
10385 if (PyErr_Occurred()) SWIG_fail;
10386 }
10387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10388 {
10389 if (temp1)
10390 delete arg1;
10391 }
10392 return resultobj;
10393 fail:
10394 {
10395 if (temp1)
10396 delete arg1;
10397 }
10398 return NULL;
10399 }
10400
10401
10402 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj = 0;
10404 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10405 int arg2 = (int) wxID_ANY ;
10406 wxPyTimer *result = 0 ;
10407 void *argp1 = 0 ;
10408 int res1 = 0 ;
10409 int val2 ;
10410 int ecode2 = 0 ;
10411 PyObject * obj0 = 0 ;
10412 PyObject * obj1 = 0 ;
10413 char * kwnames[] = {
10414 (char *) "owner",(char *) "id", NULL
10415 };
10416
10417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10418 if (obj0) {
10419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10420 if (!SWIG_IsOK(res1)) {
10421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10422 }
10423 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10424 }
10425 if (obj1) {
10426 ecode2 = SWIG_AsVal_int(obj1, &val2);
10427 if (!SWIG_IsOK(ecode2)) {
10428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10429 }
10430 arg2 = static_cast< int >(val2);
10431 }
10432 {
10433 if (!wxPyCheckForApp()) SWIG_fail;
10434 PyThreadState* __tstate = wxPyBeginAllowThreads();
10435 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10436 wxPyEndAllowThreads(__tstate);
10437 if (PyErr_Occurred()) SWIG_fail;
10438 }
10439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10440 return resultobj;
10441 fail:
10442 return NULL;
10443 }
10444
10445
10446 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10447 PyObject *resultobj = 0;
10448 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10449 void *argp1 = 0 ;
10450 int res1 = 0 ;
10451 PyObject *swig_obj[1] ;
10452
10453 if (!args) SWIG_fail;
10454 swig_obj[0] = args;
10455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10456 if (!SWIG_IsOK(res1)) {
10457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10458 }
10459 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10460 {
10461 PyThreadState* __tstate = wxPyBeginAllowThreads();
10462 delete arg1;
10463
10464 wxPyEndAllowThreads(__tstate);
10465 if (PyErr_Occurred()) SWIG_fail;
10466 }
10467 resultobj = SWIG_Py_Void();
10468 return resultobj;
10469 fail:
10470 return NULL;
10471 }
10472
10473
10474 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj = 0;
10476 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10477 PyObject *arg2 = (PyObject *) 0 ;
10478 PyObject *arg3 = (PyObject *) 0 ;
10479 int arg4 = (int) 1 ;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 int val4 ;
10483 int ecode4 = 0 ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486 PyObject * obj2 = 0 ;
10487 PyObject * obj3 = 0 ;
10488 char * kwnames[] = {
10489 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10490 };
10491
10492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10496 }
10497 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10498 arg2 = obj1;
10499 arg3 = obj2;
10500 if (obj3) {
10501 ecode4 = SWIG_AsVal_int(obj3, &val4);
10502 if (!SWIG_IsOK(ecode4)) {
10503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10504 }
10505 arg4 = static_cast< int >(val4);
10506 }
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_Py_Void();
10514 return resultobj;
10515 fail:
10516 return NULL;
10517 }
10518
10519
10520 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10521 PyObject *resultobj = 0;
10522 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10523 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10524 int arg3 = (int) wxID_ANY ;
10525 void *argp1 = 0 ;
10526 int res1 = 0 ;
10527 void *argp2 = 0 ;
10528 int res2 = 0 ;
10529 int val3 ;
10530 int ecode3 = 0 ;
10531 PyObject * obj0 = 0 ;
10532 PyObject * obj1 = 0 ;
10533 PyObject * obj2 = 0 ;
10534 char * kwnames[] = {
10535 (char *) "self",(char *) "owner",(char *) "id", NULL
10536 };
10537
10538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10540 if (!SWIG_IsOK(res1)) {
10541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10542 }
10543 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10544 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10545 if (!SWIG_IsOK(res2)) {
10546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10547 }
10548 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10549 if (obj2) {
10550 ecode3 = SWIG_AsVal_int(obj2, &val3);
10551 if (!SWIG_IsOK(ecode3)) {
10552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10553 }
10554 arg3 = static_cast< int >(val3);
10555 }
10556 {
10557 PyThreadState* __tstate = wxPyBeginAllowThreads();
10558 (arg1)->SetOwner(arg2,arg3);
10559 wxPyEndAllowThreads(__tstate);
10560 if (PyErr_Occurred()) SWIG_fail;
10561 }
10562 resultobj = SWIG_Py_Void();
10563 return resultobj;
10564 fail:
10565 return NULL;
10566 }
10567
10568
10569 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10570 PyObject *resultobj = 0;
10571 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10572 wxEvtHandler *result = 0 ;
10573 void *argp1 = 0 ;
10574 int res1 = 0 ;
10575 PyObject *swig_obj[1] ;
10576
10577 if (!args) SWIG_fail;
10578 swig_obj[0] = args;
10579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10580 if (!SWIG_IsOK(res1)) {
10581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10582 }
10583 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxEvtHandler *)(arg1)->GetOwner();
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 {
10591 resultobj = wxPyMake_wxObject(result, 0);
10592 }
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj = 0;
10601 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10602 int arg2 = (int) -1 ;
10603 bool arg3 = (bool) false ;
10604 bool result;
10605 void *argp1 = 0 ;
10606 int res1 = 0 ;
10607 int val2 ;
10608 int ecode2 = 0 ;
10609 bool val3 ;
10610 int ecode3 = 0 ;
10611 PyObject * obj0 = 0 ;
10612 PyObject * obj1 = 0 ;
10613 PyObject * obj2 = 0 ;
10614 char * kwnames[] = {
10615 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10616 };
10617
10618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10620 if (!SWIG_IsOK(res1)) {
10621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10622 }
10623 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10624 if (obj1) {
10625 ecode2 = SWIG_AsVal_int(obj1, &val2);
10626 if (!SWIG_IsOK(ecode2)) {
10627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10628 }
10629 arg2 = static_cast< int >(val2);
10630 }
10631 if (obj2) {
10632 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10633 if (!SWIG_IsOK(ecode3)) {
10634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10635 }
10636 arg3 = static_cast< bool >(val3);
10637 }
10638 {
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = (bool)(arg1)->Start(arg2,arg3);
10641 wxPyEndAllowThreads(__tstate);
10642 if (PyErr_Occurred()) SWIG_fail;
10643 }
10644 {
10645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10646 }
10647 return resultobj;
10648 fail:
10649 return NULL;
10650 }
10651
10652
10653 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10654 PyObject *resultobj = 0;
10655 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10656 void *argp1 = 0 ;
10657 int res1 = 0 ;
10658 PyObject *swig_obj[1] ;
10659
10660 if (!args) SWIG_fail;
10661 swig_obj[0] = args;
10662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10663 if (!SWIG_IsOK(res1)) {
10664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10665 }
10666 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 (arg1)->Stop();
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 resultobj = SWIG_Py_Void();
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10681 PyObject *resultobj = 0;
10682 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10683 void *argp1 = 0 ;
10684 int res1 = 0 ;
10685 PyObject *swig_obj[1] ;
10686
10687 if (!args) SWIG_fail;
10688 swig_obj[0] = args;
10689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10690 if (!SWIG_IsOK(res1)) {
10691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10692 }
10693 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 (arg1)->Notify();
10697 wxPyEndAllowThreads(__tstate);
10698 if (PyErr_Occurred()) SWIG_fail;
10699 }
10700 resultobj = SWIG_Py_Void();
10701 return resultobj;
10702 fail:
10703 return NULL;
10704 }
10705
10706
10707 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10708 PyObject *resultobj = 0;
10709 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10710 bool result;
10711 void *argp1 = 0 ;
10712 int res1 = 0 ;
10713 PyObject *swig_obj[1] ;
10714
10715 if (!args) SWIG_fail;
10716 swig_obj[0] = args;
10717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10718 if (!SWIG_IsOK(res1)) {
10719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10720 }
10721 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10722 {
10723 PyThreadState* __tstate = wxPyBeginAllowThreads();
10724 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10725 wxPyEndAllowThreads(__tstate);
10726 if (PyErr_Occurred()) SWIG_fail;
10727 }
10728 {
10729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10730 }
10731 return resultobj;
10732 fail:
10733 return NULL;
10734 }
10735
10736
10737 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10738 PyObject *resultobj = 0;
10739 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10740 int result;
10741 void *argp1 = 0 ;
10742 int res1 = 0 ;
10743 PyObject *swig_obj[1] ;
10744
10745 if (!args) SWIG_fail;
10746 swig_obj[0] = args;
10747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10748 if (!SWIG_IsOK(res1)) {
10749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10750 }
10751 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 resultobj = SWIG_From_int(static_cast< int >(result));
10759 return resultobj;
10760 fail:
10761 return NULL;
10762 }
10763
10764
10765 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10766 PyObject *resultobj = 0;
10767 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10768 int result;
10769 void *argp1 = 0 ;
10770 int res1 = 0 ;
10771 PyObject *swig_obj[1] ;
10772
10773 if (!args) SWIG_fail;
10774 swig_obj[0] = args;
10775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10776 if (!SWIG_IsOK(res1)) {
10777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10778 }
10779 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10780 {
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 result = (int)((wxPyTimer const *)arg1)->GetId();
10783 wxPyEndAllowThreads(__tstate);
10784 if (PyErr_Occurred()) SWIG_fail;
10785 }
10786 resultobj = SWIG_From_int(static_cast< int >(result));
10787 return resultobj;
10788 fail:
10789 return NULL;
10790 }
10791
10792
10793 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10794 PyObject *resultobj = 0;
10795 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10796 bool result;
10797 void *argp1 = 0 ;
10798 int res1 = 0 ;
10799 PyObject *swig_obj[1] ;
10800
10801 if (!args) SWIG_fail;
10802 swig_obj[0] = args;
10803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10804 if (!SWIG_IsOK(res1)) {
10805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10806 }
10807 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 {
10815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10816 }
10817 return resultobj;
10818 fail:
10819 return NULL;
10820 }
10821
10822
10823 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10824 PyObject *obj;
10825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10826 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10827 return SWIG_Py_Void();
10828 }
10829
10830 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10831 return SWIG_Python_InitShadowInstance(args);
10832 }
10833
10834 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj = 0;
10836 int arg1 = (int) 0 ;
10837 int arg2 = (int) 0 ;
10838 wxTimerEvent *result = 0 ;
10839 int val1 ;
10840 int ecode1 = 0 ;
10841 int val2 ;
10842 int ecode2 = 0 ;
10843 PyObject * obj0 = 0 ;
10844 PyObject * obj1 = 0 ;
10845 char * kwnames[] = {
10846 (char *) "timerid",(char *) "interval", NULL
10847 };
10848
10849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10850 if (obj0) {
10851 ecode1 = SWIG_AsVal_int(obj0, &val1);
10852 if (!SWIG_IsOK(ecode1)) {
10853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10854 }
10855 arg1 = static_cast< int >(val1);
10856 }
10857 if (obj1) {
10858 ecode2 = SWIG_AsVal_int(obj1, &val2);
10859 if (!SWIG_IsOK(ecode2)) {
10860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10861 }
10862 arg2 = static_cast< int >(val2);
10863 }
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 PyObject *resultobj = 0;
10879 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10880 int result;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 PyObject *swig_obj[1] ;
10884
10885 if (!args) SWIG_fail;
10886 swig_obj[0] = args;
10887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10888 if (!SWIG_IsOK(res1)) {
10889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10890 }
10891 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 resultobj = SWIG_From_int(static_cast< int >(result));
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10906 PyObject *obj;
10907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10908 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10909 return SWIG_Py_Void();
10910 }
10911
10912 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10913 return SWIG_Python_InitShadowInstance(args);
10914 }
10915
10916 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10917 PyObject *resultobj = 0;
10918 wxTimer *arg1 = 0 ;
10919 wxTimerRunner *result = 0 ;
10920 void *argp1 = 0 ;
10921 int res1 = 0 ;
10922
10923 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10925 if (!SWIG_IsOK(res1)) {
10926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10927 }
10928 if (!argp1) {
10929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10930 }
10931 arg1 = reinterpret_cast< wxTimer * >(argp1);
10932 {
10933 if (!wxPyCheckForApp()) SWIG_fail;
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10947 PyObject *resultobj = 0;
10948 wxTimer *arg1 = 0 ;
10949 int arg2 ;
10950 bool arg3 = (bool) false ;
10951 wxTimerRunner *result = 0 ;
10952 void *argp1 = 0 ;
10953 int res1 = 0 ;
10954 int val2 ;
10955 int ecode2 = 0 ;
10956 bool val3 ;
10957 int ecode3 = 0 ;
10958
10959 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10961 if (!SWIG_IsOK(res1)) {
10962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10963 }
10964 if (!argp1) {
10965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10966 }
10967 arg1 = reinterpret_cast< wxTimer * >(argp1);
10968 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10969 if (!SWIG_IsOK(ecode2)) {
10970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10971 }
10972 arg2 = static_cast< int >(val2);
10973 if (swig_obj[2]) {
10974 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10975 if (!SWIG_IsOK(ecode3)) {
10976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10977 }
10978 arg3 = static_cast< bool >(val3);
10979 }
10980 {
10981 if (!wxPyCheckForApp()) SWIG_fail;
10982 PyThreadState* __tstate = wxPyBeginAllowThreads();
10983 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10984 wxPyEndAllowThreads(__tstate);
10985 if (PyErr_Occurred()) SWIG_fail;
10986 }
10987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10988 return resultobj;
10989 fail:
10990 return NULL;
10991 }
10992
10993
10994 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10995 int argc;
10996 PyObject *argv[4];
10997
10998 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10999 --argc;
11000 if (argc == 1) {
11001 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
11002 }
11003 if ((argc >= 2) && (argc <= 3)) {
11004 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
11005 }
11006
11007 fail:
11008 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11009 return NULL;
11010 }
11011
11012
11013 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11014 PyObject *resultobj = 0;
11015 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11016 void *argp1 = 0 ;
11017 int res1 = 0 ;
11018 PyObject *swig_obj[1] ;
11019
11020 if (!args) SWIG_fail;
11021 swig_obj[0] = args;
11022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11023 if (!SWIG_IsOK(res1)) {
11024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11025 }
11026 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11027 {
11028 PyThreadState* __tstate = wxPyBeginAllowThreads();
11029 delete arg1;
11030
11031 wxPyEndAllowThreads(__tstate);
11032 if (PyErr_Occurred()) SWIG_fail;
11033 }
11034 resultobj = SWIG_Py_Void();
11035 return resultobj;
11036 fail:
11037 return NULL;
11038 }
11039
11040
11041 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj = 0;
11043 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11044 int arg2 ;
11045 bool arg3 = (bool) false ;
11046 void *argp1 = 0 ;
11047 int res1 = 0 ;
11048 int val2 ;
11049 int ecode2 = 0 ;
11050 bool val3 ;
11051 int ecode3 = 0 ;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 PyObject * obj2 = 0 ;
11055 char * kwnames[] = {
11056 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11057 };
11058
11059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11061 if (!SWIG_IsOK(res1)) {
11062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11063 }
11064 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11065 ecode2 = SWIG_AsVal_int(obj1, &val2);
11066 if (!SWIG_IsOK(ecode2)) {
11067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11068 }
11069 arg2 = static_cast< int >(val2);
11070 if (obj2) {
11071 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11072 if (!SWIG_IsOK(ecode3)) {
11073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11074 }
11075 arg3 = static_cast< bool >(val3);
11076 }
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 (arg1)->Start(arg2,arg3);
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 resultobj = SWIG_Py_Void();
11084 return resultobj;
11085 fail:
11086 return NULL;
11087 }
11088
11089
11090 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11091 PyObject *obj;
11092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11093 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11094 return SWIG_Py_Void();
11095 }
11096
11097 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11098 return SWIG_Python_InitShadowInstance(args);
11099 }
11100
11101 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11102 PyObject *resultobj = 0;
11103 wxLog *result = 0 ;
11104
11105 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11106 {
11107 PyThreadState* __tstate = wxPyBeginAllowThreads();
11108 result = (wxLog *)new wxLog();
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11113 return resultobj;
11114 fail:
11115 return NULL;
11116 }
11117
11118
11119 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11120 PyObject *resultobj = 0;
11121 wxLog *arg1 = (wxLog *) 0 ;
11122 void *argp1 = 0 ;
11123 int res1 = 0 ;
11124 PyObject *swig_obj[1] ;
11125
11126 if (!args) SWIG_fail;
11127 swig_obj[0] = args;
11128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11129 if (!SWIG_IsOK(res1)) {
11130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11131 }
11132 arg1 = reinterpret_cast< wxLog * >(argp1);
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 delete arg1;
11136
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 resultobj = SWIG_Py_Void();
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11148 PyObject *resultobj = 0;
11149 bool result;
11150
11151 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11152 {
11153 PyThreadState* __tstate = wxPyBeginAllowThreads();
11154 result = (bool)wxLog::IsEnabled();
11155 wxPyEndAllowThreads(__tstate);
11156 if (PyErr_Occurred()) SWIG_fail;
11157 }
11158 {
11159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11160 }
11161 return resultobj;
11162 fail:
11163 return NULL;
11164 }
11165
11166
11167 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11168 PyObject *resultobj = 0;
11169 bool arg1 = (bool) true ;
11170 bool result;
11171 bool val1 ;
11172 int ecode1 = 0 ;
11173 PyObject * obj0 = 0 ;
11174 char * kwnames[] = {
11175 (char *) "doIt", NULL
11176 };
11177
11178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11179 if (obj0) {
11180 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11181 if (!SWIG_IsOK(ecode1)) {
11182 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11183 }
11184 arg1 = static_cast< bool >(val1);
11185 }
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (bool)wxLog::EnableLogging(arg1);
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 {
11193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11194 }
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11202 PyObject *resultobj = 0;
11203 wxLogLevel arg1 ;
11204 wxChar *arg2 = (wxChar *) 0 ;
11205 time_t arg3 ;
11206 unsigned long val1 ;
11207 int ecode1 = 0 ;
11208 void *argp2 = 0 ;
11209 int res2 = 0 ;
11210 unsigned int val3 ;
11211 int ecode3 = 0 ;
11212 PyObject * obj0 = 0 ;
11213 PyObject * obj1 = 0 ;
11214 PyObject * obj2 = 0 ;
11215 char * kwnames[] = {
11216 (char *) "level",(char *) "szString",(char *) "t", NULL
11217 };
11218
11219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11220 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11221 if (!SWIG_IsOK(ecode1)) {
11222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11223 }
11224 arg1 = static_cast< wxLogLevel >(val1);
11225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11226 if (!SWIG_IsOK(res2)) {
11227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11228 }
11229 arg2 = reinterpret_cast< wxChar * >(argp2);
11230 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11231 if (!SWIG_IsOK(ecode3)) {
11232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11233 }
11234 arg3 = static_cast< time_t >(val3);
11235 {
11236 PyThreadState* __tstate = wxPyBeginAllowThreads();
11237 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11238 wxPyEndAllowThreads(__tstate);
11239 if (PyErr_Occurred()) SWIG_fail;
11240 }
11241 resultobj = SWIG_Py_Void();
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11249 PyObject *resultobj = 0;
11250 wxLog *arg1 = (wxLog *) 0 ;
11251 void *argp1 = 0 ;
11252 int res1 = 0 ;
11253 PyObject *swig_obj[1] ;
11254
11255 if (!args) SWIG_fail;
11256 swig_obj[0] = args;
11257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11258 if (!SWIG_IsOK(res1)) {
11259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11260 }
11261 arg1 = reinterpret_cast< wxLog * >(argp1);
11262 {
11263 PyThreadState* __tstate = wxPyBeginAllowThreads();
11264 (arg1)->Flush();
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 resultobj = SWIG_Py_Void();
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
11275 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11276 PyObject *resultobj = 0;
11277
11278 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11279 {
11280 PyThreadState* __tstate = wxPyBeginAllowThreads();
11281 wxLog::FlushActive();
11282 wxPyEndAllowThreads(__tstate);
11283 if (PyErr_Occurred()) SWIG_fail;
11284 }
11285 resultobj = SWIG_Py_Void();
11286 return resultobj;
11287 fail:
11288 return NULL;
11289 }
11290
11291
11292 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11293 PyObject *resultobj = 0;
11294 wxLog *result = 0 ;
11295
11296 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11297 {
11298 PyThreadState* __tstate = wxPyBeginAllowThreads();
11299 result = (wxLog *)wxLog::GetActiveTarget();
11300 wxPyEndAllowThreads(__tstate);
11301 if (PyErr_Occurred()) SWIG_fail;
11302 }
11303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11311 PyObject *resultobj = 0;
11312 wxLog *arg1 = (wxLog *) 0 ;
11313 wxLog *result = 0 ;
11314 int res1 = 0 ;
11315 PyObject * obj0 = 0 ;
11316 char * kwnames[] = {
11317 (char *) "pLogger", NULL
11318 };
11319
11320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11321 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11322 if (!SWIG_IsOK(res1)) {
11323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11324 }
11325 {
11326 PyThreadState* __tstate = wxPyBeginAllowThreads();
11327 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11328 wxPyEndAllowThreads(__tstate);
11329 if (PyErr_Occurred()) SWIG_fail;
11330 }
11331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11332 return resultobj;
11333 fail:
11334 return NULL;
11335 }
11336
11337
11338 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11339 PyObject *resultobj = 0;
11340
11341 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11342 {
11343 PyThreadState* __tstate = wxPyBeginAllowThreads();
11344 wxLog::Suspend();
11345 wxPyEndAllowThreads(__tstate);
11346 if (PyErr_Occurred()) SWIG_fail;
11347 }
11348 resultobj = SWIG_Py_Void();
11349 return resultobj;
11350 fail:
11351 return NULL;
11352 }
11353
11354
11355 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11356 PyObject *resultobj = 0;
11357
11358 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 wxLog::Resume();
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 resultobj = SWIG_Py_Void();
11366 return resultobj;
11367 fail:
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj = 0;
11374 bool arg1 = (bool) true ;
11375 bool val1 ;
11376 int ecode1 = 0 ;
11377 PyObject * obj0 = 0 ;
11378 char * kwnames[] = {
11379 (char *) "bVerbose", NULL
11380 };
11381
11382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11383 if (obj0) {
11384 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11385 if (!SWIG_IsOK(ecode1)) {
11386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11387 }
11388 arg1 = static_cast< bool >(val1);
11389 }
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 wxLog::SetVerbose(arg1);
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 resultobj = SWIG_Py_Void();
11397 return resultobj;
11398 fail:
11399 return NULL;
11400 }
11401
11402
11403 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11404 PyObject *resultobj = 0;
11405 wxLogLevel arg1 ;
11406 unsigned long val1 ;
11407 int ecode1 = 0 ;
11408 PyObject * obj0 = 0 ;
11409 char * kwnames[] = {
11410 (char *) "logLevel", NULL
11411 };
11412
11413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11414 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11415 if (!SWIG_IsOK(ecode1)) {
11416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11417 }
11418 arg1 = static_cast< wxLogLevel >(val1);
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 wxLog::SetLogLevel(arg1);
11422 wxPyEndAllowThreads(__tstate);
11423 if (PyErr_Occurred()) SWIG_fail;
11424 }
11425 resultobj = SWIG_Py_Void();
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11433 PyObject *resultobj = 0;
11434
11435 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 wxLog::DontCreateOnDemand();
11439 wxPyEndAllowThreads(__tstate);
11440 if (PyErr_Occurred()) SWIG_fail;
11441 }
11442 resultobj = SWIG_Py_Void();
11443 return resultobj;
11444 fail:
11445 return NULL;
11446 }
11447
11448
11449 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj = 0;
11451 bool arg1 = (bool) true ;
11452 bool val1 ;
11453 int ecode1 = 0 ;
11454 PyObject * obj0 = 0 ;
11455 char * kwnames[] = {
11456 (char *) "bRepetCounting", NULL
11457 };
11458
11459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
11460 if (obj0) {
11461 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11462 if (!SWIG_IsOK(ecode1)) {
11463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
11464 }
11465 arg1 = static_cast< bool >(val1);
11466 }
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 wxLog::SetRepetitionCounting(arg1);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 return resultobj;
11475 fail:
11476 return NULL;
11477 }
11478
11479
11480 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11481 PyObject *resultobj = 0;
11482 bool result;
11483
11484 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (bool)wxLog::GetRepetitionCounting();
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 {
11492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11493 }
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj = 0;
11502 wxTraceMask arg1 ;
11503 unsigned long val1 ;
11504 int ecode1 = 0 ;
11505 PyObject * obj0 = 0 ;
11506 char * kwnames[] = {
11507 (char *) "ulMask", NULL
11508 };
11509
11510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11511 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11512 if (!SWIG_IsOK(ecode1)) {
11513 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11514 }
11515 arg1 = static_cast< wxTraceMask >(val1);
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 wxLog::SetTraceMask(arg1);
11519 wxPyEndAllowThreads(__tstate);
11520 if (PyErr_Occurred()) SWIG_fail;
11521 }
11522 resultobj = SWIG_Py_Void();
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj = 0;
11531 wxString *arg1 = 0 ;
11532 bool temp1 = false ;
11533 PyObject * obj0 = 0 ;
11534 char * kwnames[] = {
11535 (char *) "str", NULL
11536 };
11537
11538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11539 {
11540 arg1 = wxString_in_helper(obj0);
11541 if (arg1 == NULL) SWIG_fail;
11542 temp1 = true;
11543 }
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 wxLog::AddTraceMask((wxString const &)*arg1);
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 resultobj = SWIG_Py_Void();
11551 {
11552 if (temp1)
11553 delete arg1;
11554 }
11555 return resultobj;
11556 fail:
11557 {
11558 if (temp1)
11559 delete arg1;
11560 }
11561 return NULL;
11562 }
11563
11564
11565 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj = 0;
11567 wxString *arg1 = 0 ;
11568 bool temp1 = false ;
11569 PyObject * obj0 = 0 ;
11570 char * kwnames[] = {
11571 (char *) "str", NULL
11572 };
11573
11574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11575 {
11576 arg1 = wxString_in_helper(obj0);
11577 if (arg1 == NULL) SWIG_fail;
11578 temp1 = true;
11579 }
11580 {
11581 PyThreadState* __tstate = wxPyBeginAllowThreads();
11582 wxLog::RemoveTraceMask((wxString const &)*arg1);
11583 wxPyEndAllowThreads(__tstate);
11584 if (PyErr_Occurred()) SWIG_fail;
11585 }
11586 resultobj = SWIG_Py_Void();
11587 {
11588 if (temp1)
11589 delete arg1;
11590 }
11591 return resultobj;
11592 fail:
11593 {
11594 if (temp1)
11595 delete arg1;
11596 }
11597 return NULL;
11598 }
11599
11600
11601 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11602 PyObject *resultobj = 0;
11603
11604 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11605 {
11606 PyThreadState* __tstate = wxPyBeginAllowThreads();
11607 wxLog::ClearTraceMasks();
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 resultobj = SWIG_Py_Void();
11612 return resultobj;
11613 fail:
11614 return NULL;
11615 }
11616
11617
11618 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11619 PyObject *resultobj = 0;
11620 wxArrayString *result = 0 ;
11621
11622 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11623 {
11624 PyThreadState* __tstate = wxPyBeginAllowThreads();
11625 {
11626 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11627 result = (wxArrayString *) &_result_ref;
11628 }
11629 wxPyEndAllowThreads(__tstate);
11630 if (PyErr_Occurred()) SWIG_fail;
11631 }
11632 {
11633 resultobj = wxArrayString2PyList_helper(*result);
11634 }
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11642 PyObject *resultobj = 0;
11643 wxChar *arg1 = (wxChar *) 0 ;
11644 void *argp1 = 0 ;
11645 int res1 = 0 ;
11646 PyObject * obj0 = 0 ;
11647 char * kwnames[] = {
11648 (char *) "ts", NULL
11649 };
11650
11651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11655 }
11656 arg1 = reinterpret_cast< wxChar * >(argp1);
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 wxLog::SetTimestamp((wxChar const *)arg1);
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 resultobj = SWIG_Py_Void();
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11671 PyObject *resultobj = 0;
11672 bool result;
11673
11674 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 result = (bool)wxLog::GetVerbose();
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 {
11682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11683 }
11684 return resultobj;
11685 fail:
11686 return NULL;
11687 }
11688
11689
11690 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11691 PyObject *resultobj = 0;
11692 wxTraceMask result;
11693
11694 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11695 {
11696 PyThreadState* __tstate = wxPyBeginAllowThreads();
11697 result = (wxTraceMask)wxLog::GetTraceMask();
11698 wxPyEndAllowThreads(__tstate);
11699 if (PyErr_Occurred()) SWIG_fail;
11700 }
11701 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11702 return resultobj;
11703 fail:
11704 return NULL;
11705 }
11706
11707
11708 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11709 PyObject *resultobj = 0;
11710 wxChar *arg1 = (wxChar *) 0 ;
11711 bool result;
11712 void *argp1 = 0 ;
11713 int res1 = 0 ;
11714 PyObject * obj0 = 0 ;
11715 char * kwnames[] = {
11716 (char *) "mask", NULL
11717 };
11718
11719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11721 if (!SWIG_IsOK(res1)) {
11722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11723 }
11724 arg1 = reinterpret_cast< wxChar * >(argp1);
11725 {
11726 PyThreadState* __tstate = wxPyBeginAllowThreads();
11727 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 {
11732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11733 }
11734 return resultobj;
11735 fail:
11736 return NULL;
11737 }
11738
11739
11740 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11741 PyObject *resultobj = 0;
11742 wxLogLevel result;
11743
11744 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 result = (wxLogLevel)wxLog::GetLogLevel();
11748 wxPyEndAllowThreads(__tstate);
11749 if (PyErr_Occurred()) SWIG_fail;
11750 }
11751 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11752 return resultobj;
11753 fail:
11754 return NULL;
11755 }
11756
11757
11758 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11759 PyObject *resultobj = 0;
11760 wxChar *result = 0 ;
11761
11762 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 result = (wxChar *)wxLog::GetTimestamp();
11766 wxPyEndAllowThreads(__tstate);
11767 if (PyErr_Occurred()) SWIG_fail;
11768 }
11769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11770 return resultobj;
11771 fail:
11772 return NULL;
11773 }
11774
11775
11776 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11777 PyObject *resultobj = 0;
11778 wxString result;
11779
11780 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = wxLog_TimeStamp();
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 {
11788 #if wxUSE_UNICODE
11789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11790 #else
11791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11792 #endif
11793 }
11794 return resultobj;
11795 fail:
11796 return NULL;
11797 }
11798
11799
11800 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11801 PyObject *resultobj = 0;
11802 wxLog *arg1 = (wxLog *) 0 ;
11803 void *argp1 = 0 ;
11804 int res1 = 0 ;
11805 PyObject *swig_obj[1] ;
11806
11807 if (!args) SWIG_fail;
11808 swig_obj[0] = args;
11809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11812 }
11813 arg1 = reinterpret_cast< wxLog * >(argp1);
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 wxLog_Destroy(arg1);
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 resultobj = SWIG_Py_Void();
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11828 PyObject *obj;
11829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11830 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11831 return SWIG_Py_Void();
11832 }
11833
11834 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 return SWIG_Python_InitShadowInstance(args);
11836 }
11837
11838 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11839 PyObject *resultobj = 0;
11840 wxLogStderr *result = 0 ;
11841
11842 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11843 {
11844 PyThreadState* __tstate = wxPyBeginAllowThreads();
11845 result = (wxLogStderr *)new wxLogStderr();
11846 wxPyEndAllowThreads(__tstate);
11847 if (PyErr_Occurred()) SWIG_fail;
11848 }
11849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11850 return resultobj;
11851 fail:
11852 return NULL;
11853 }
11854
11855
11856 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11857 PyObject *obj;
11858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11859 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11860 return SWIG_Py_Void();
11861 }
11862
11863 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11864 return SWIG_Python_InitShadowInstance(args);
11865 }
11866
11867 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11868 PyObject *resultobj = 0;
11869 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11870 wxLogTextCtrl *result = 0 ;
11871 void *argp1 = 0 ;
11872 int res1 = 0 ;
11873 PyObject * obj0 = 0 ;
11874 char * kwnames[] = {
11875 (char *) "pTextCtrl", NULL
11876 };
11877
11878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11880 if (!SWIG_IsOK(res1)) {
11881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11882 }
11883 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11891 return resultobj;
11892 fail:
11893 return NULL;
11894 }
11895
11896
11897 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11898 PyObject *obj;
11899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11900 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11901 return SWIG_Py_Void();
11902 }
11903
11904 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11905 return SWIG_Python_InitShadowInstance(args);
11906 }
11907
11908 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11909 PyObject *resultobj = 0;
11910 wxLogGui *result = 0 ;
11911
11912 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11913 {
11914 PyThreadState* __tstate = wxPyBeginAllowThreads();
11915 result = (wxLogGui *)new wxLogGui();
11916 wxPyEndAllowThreads(__tstate);
11917 if (PyErr_Occurred()) SWIG_fail;
11918 }
11919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11920 return resultobj;
11921 fail:
11922 return NULL;
11923 }
11924
11925
11926 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11927 PyObject *obj;
11928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11929 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11930 return SWIG_Py_Void();
11931 }
11932
11933 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11934 return SWIG_Python_InitShadowInstance(args);
11935 }
11936
11937 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj = 0;
11939 wxFrame *arg1 = (wxFrame *) 0 ;
11940 wxString *arg2 = 0 ;
11941 bool arg3 = (bool) true ;
11942 bool arg4 = (bool) true ;
11943 wxLogWindow *result = 0 ;
11944 void *argp1 = 0 ;
11945 int res1 = 0 ;
11946 bool temp2 = false ;
11947 bool val3 ;
11948 int ecode3 = 0 ;
11949 bool val4 ;
11950 int ecode4 = 0 ;
11951 PyObject * obj0 = 0 ;
11952 PyObject * obj1 = 0 ;
11953 PyObject * obj2 = 0 ;
11954 PyObject * obj3 = 0 ;
11955 char * kwnames[] = {
11956 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11957 };
11958
11959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11961 if (!SWIG_IsOK(res1)) {
11962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11963 }
11964 arg1 = reinterpret_cast< wxFrame * >(argp1);
11965 {
11966 arg2 = wxString_in_helper(obj1);
11967 if (arg2 == NULL) SWIG_fail;
11968 temp2 = true;
11969 }
11970 if (obj2) {
11971 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11972 if (!SWIG_IsOK(ecode3)) {
11973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11974 }
11975 arg3 = static_cast< bool >(val3);
11976 }
11977 if (obj3) {
11978 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11979 if (!SWIG_IsOK(ecode4)) {
11980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11981 }
11982 arg4 = static_cast< bool >(val4);
11983 }
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11991 {
11992 if (temp2)
11993 delete arg2;
11994 }
11995 return resultobj;
11996 fail:
11997 {
11998 if (temp2)
11999 delete arg2;
12000 }
12001 return NULL;
12002 }
12003
12004
12005 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12006 PyObject *resultobj = 0;
12007 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12008 bool arg2 = (bool) true ;
12009 void *argp1 = 0 ;
12010 int res1 = 0 ;
12011 bool val2 ;
12012 int ecode2 = 0 ;
12013 PyObject * obj0 = 0 ;
12014 PyObject * obj1 = 0 ;
12015 char * kwnames[] = {
12016 (char *) "self",(char *) "bShow", NULL
12017 };
12018
12019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12021 if (!SWIG_IsOK(res1)) {
12022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12023 }
12024 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12025 if (obj1) {
12026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12027 if (!SWIG_IsOK(ecode2)) {
12028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12029 }
12030 arg2 = static_cast< bool >(val2);
12031 }
12032 {
12033 PyThreadState* __tstate = wxPyBeginAllowThreads();
12034 (arg1)->Show(arg2);
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 resultobj = SWIG_Py_Void();
12039 return resultobj;
12040 fail:
12041 return NULL;
12042 }
12043
12044
12045 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12046 PyObject *resultobj = 0;
12047 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12048 wxFrame *result = 0 ;
12049 void *argp1 = 0 ;
12050 int res1 = 0 ;
12051 PyObject *swig_obj[1] ;
12052
12053 if (!args) SWIG_fail;
12054 swig_obj[0] = args;
12055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12058 }
12059 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12063 wxPyEndAllowThreads(__tstate);
12064 if (PyErr_Occurred()) SWIG_fail;
12065 }
12066 {
12067 resultobj = wxPyMake_wxObject(result, (bool)0);
12068 }
12069 return resultobj;
12070 fail:
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12076 PyObject *resultobj = 0;
12077 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12078 wxLog *result = 0 ;
12079 void *argp1 = 0 ;
12080 int res1 = 0 ;
12081 PyObject *swig_obj[1] ;
12082
12083 if (!args) SWIG_fail;
12084 swig_obj[0] = args;
12085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12086 if (!SWIG_IsOK(res1)) {
12087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12088 }
12089 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12090 {
12091 PyThreadState* __tstate = wxPyBeginAllowThreads();
12092 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12097 return resultobj;
12098 fail:
12099 return NULL;
12100 }
12101
12102
12103 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12104 PyObject *resultobj = 0;
12105 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12106 bool result;
12107 void *argp1 = 0 ;
12108 int res1 = 0 ;
12109 PyObject *swig_obj[1] ;
12110
12111 if (!args) SWIG_fail;
12112 swig_obj[0] = args;
12113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12114 if (!SWIG_IsOK(res1)) {
12115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12116 }
12117 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12118 {
12119 PyThreadState* __tstate = wxPyBeginAllowThreads();
12120 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
12121 wxPyEndAllowThreads(__tstate);
12122 if (PyErr_Occurred()) SWIG_fail;
12123 }
12124 {
12125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12126 }
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj = 0;
12135 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12136 bool arg2 ;
12137 void *argp1 = 0 ;
12138 int res1 = 0 ;
12139 bool val2 ;
12140 int ecode2 = 0 ;
12141 PyObject * obj0 = 0 ;
12142 PyObject * obj1 = 0 ;
12143 char * kwnames[] = {
12144 (char *) "self",(char *) "bDoPass", NULL
12145 };
12146
12147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12149 if (!SWIG_IsOK(res1)) {
12150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12151 }
12152 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12153 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12154 if (!SWIG_IsOK(ecode2)) {
12155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12156 }
12157 arg2 = static_cast< bool >(val2);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 (arg1)->PassMessages(arg2);
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_Py_Void();
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *obj;
12173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12174 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
12175 return SWIG_Py_Void();
12176 }
12177
12178 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12179 return SWIG_Python_InitShadowInstance(args);
12180 }
12181
12182 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12183 PyObject *resultobj = 0;
12184 wxLog *arg1 = (wxLog *) 0 ;
12185 wxLogChain *result = 0 ;
12186 void *argp1 = 0 ;
12187 int res1 = 0 ;
12188 PyObject * obj0 = 0 ;
12189 char * kwnames[] = {
12190 (char *) "logger", NULL
12191 };
12192
12193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12195 if (!SWIG_IsOK(res1)) {
12196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12197 }
12198 arg1 = reinterpret_cast< wxLog * >(argp1);
12199 {
12200 PyThreadState* __tstate = wxPyBeginAllowThreads();
12201 result = (wxLogChain *)new wxLogChain(arg1);
12202 wxPyEndAllowThreads(__tstate);
12203 if (PyErr_Occurred()) SWIG_fail;
12204 }
12205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12206 return resultobj;
12207 fail:
12208 return NULL;
12209 }
12210
12211
12212 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12213 PyObject *resultobj = 0;
12214 wxLogChain *arg1 = (wxLogChain *) 0 ;
12215 wxLog *arg2 = (wxLog *) 0 ;
12216 void *argp1 = 0 ;
12217 int res1 = 0 ;
12218 void *argp2 = 0 ;
12219 int res2 = 0 ;
12220 PyObject * obj0 = 0 ;
12221 PyObject * obj1 = 0 ;
12222 char * kwnames[] = {
12223 (char *) "self",(char *) "logger", NULL
12224 };
12225
12226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12228 if (!SWIG_IsOK(res1)) {
12229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12230 }
12231 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12233 if (!SWIG_IsOK(res2)) {
12234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12235 }
12236 arg2 = reinterpret_cast< wxLog * >(argp2);
12237 {
12238 PyThreadState* __tstate = wxPyBeginAllowThreads();
12239 (arg1)->SetLog(arg2);
12240 wxPyEndAllowThreads(__tstate);
12241 if (PyErr_Occurred()) SWIG_fail;
12242 }
12243 resultobj = SWIG_Py_Void();
12244 return resultobj;
12245 fail:
12246 return NULL;
12247 }
12248
12249
12250 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12251 PyObject *resultobj = 0;
12252 wxLogChain *arg1 = (wxLogChain *) 0 ;
12253 bool arg2 ;
12254 void *argp1 = 0 ;
12255 int res1 = 0 ;
12256 bool val2 ;
12257 int ecode2 = 0 ;
12258 PyObject * obj0 = 0 ;
12259 PyObject * obj1 = 0 ;
12260 char * kwnames[] = {
12261 (char *) "self",(char *) "bDoPass", NULL
12262 };
12263
12264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12266 if (!SWIG_IsOK(res1)) {
12267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12268 }
12269 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12270 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12271 if (!SWIG_IsOK(ecode2)) {
12272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12273 }
12274 arg2 = static_cast< bool >(val2);
12275 {
12276 PyThreadState* __tstate = wxPyBeginAllowThreads();
12277 (arg1)->PassMessages(arg2);
12278 wxPyEndAllowThreads(__tstate);
12279 if (PyErr_Occurred()) SWIG_fail;
12280 }
12281 resultobj = SWIG_Py_Void();
12282 return resultobj;
12283 fail:
12284 return NULL;
12285 }
12286
12287
12288 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12289 PyObject *resultobj = 0;
12290 wxLogChain *arg1 = (wxLogChain *) 0 ;
12291 bool result;
12292 void *argp1 = 0 ;
12293 int res1 = 0 ;
12294 PyObject *swig_obj[1] ;
12295
12296 if (!args) SWIG_fail;
12297 swig_obj[0] = args;
12298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12299 if (!SWIG_IsOK(res1)) {
12300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12301 }
12302 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12303 {
12304 PyThreadState* __tstate = wxPyBeginAllowThreads();
12305 result = (bool)(arg1)->IsPassingMessages();
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 {
12310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12311 }
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12319 PyObject *resultobj = 0;
12320 wxLogChain *arg1 = (wxLogChain *) 0 ;
12321 wxLog *result = 0 ;
12322 void *argp1 = 0 ;
12323 int res1 = 0 ;
12324 PyObject *swig_obj[1] ;
12325
12326 if (!args) SWIG_fail;
12327 swig_obj[0] = args;
12328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12329 if (!SWIG_IsOK(res1)) {
12330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12331 }
12332 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 result = (wxLog *)(arg1)->GetOldLog();
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12347 PyObject *obj;
12348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12349 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12350 return SWIG_Py_Void();
12351 }
12352
12353 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12354 return SWIG_Python_InitShadowInstance(args);
12355 }
12356
12357 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12358 PyObject *resultobj = 0;
12359 wxLogBuffer *result = 0 ;
12360
12361 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12362 {
12363 PyThreadState* __tstate = wxPyBeginAllowThreads();
12364 result = (wxLogBuffer *)new wxLogBuffer();
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12369 return resultobj;
12370 fail:
12371 return NULL;
12372 }
12373
12374
12375 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12376 PyObject *resultobj = 0;
12377 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12378 wxString *result = 0 ;
12379 void *argp1 = 0 ;
12380 int res1 = 0 ;
12381 PyObject *swig_obj[1] ;
12382
12383 if (!args) SWIG_fail;
12384 swig_obj[0] = args;
12385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12386 if (!SWIG_IsOK(res1)) {
12387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12388 }
12389 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12390 {
12391 PyThreadState* __tstate = wxPyBeginAllowThreads();
12392 {
12393 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12394 result = (wxString *) &_result_ref;
12395 }
12396 wxPyEndAllowThreads(__tstate);
12397 if (PyErr_Occurred()) SWIG_fail;
12398 }
12399 {
12400 #if wxUSE_UNICODE
12401 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12402 #else
12403 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12404 #endif
12405 }
12406 return resultobj;
12407 fail:
12408 return NULL;
12409 }
12410
12411
12412 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12413 PyObject *obj;
12414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12415 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12416 return SWIG_Py_Void();
12417 }
12418
12419 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12420 return SWIG_Python_InitShadowInstance(args);
12421 }
12422
12423 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12424 PyObject *resultobj = 0;
12425 unsigned long result;
12426
12427 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12428 {
12429 PyThreadState* __tstate = wxPyBeginAllowThreads();
12430 result = (unsigned long)wxSysErrorCode();
12431 wxPyEndAllowThreads(__tstate);
12432 if (PyErr_Occurred()) SWIG_fail;
12433 }
12434 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj = 0;
12443 unsigned long arg1 = (unsigned long) 0 ;
12444 wxString result;
12445 unsigned long val1 ;
12446 int ecode1 = 0 ;
12447 PyObject * obj0 = 0 ;
12448 char * kwnames[] = {
12449 (char *) "nErrCode", NULL
12450 };
12451
12452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12453 if (obj0) {
12454 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12455 if (!SWIG_IsOK(ecode1)) {
12456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12457 }
12458 arg1 = static_cast< unsigned long >(val1);
12459 }
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 result = wxSysErrorMsg(arg1);
12463 wxPyEndAllowThreads(__tstate);
12464 if (PyErr_Occurred()) SWIG_fail;
12465 }
12466 {
12467 #if wxUSE_UNICODE
12468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12469 #else
12470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12471 #endif
12472 }
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj = 0;
12481 wxString *arg1 = 0 ;
12482 bool temp1 = false ;
12483 PyObject * obj0 = 0 ;
12484 char * kwnames[] = {
12485 (char *) "msg", NULL
12486 };
12487
12488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12489 {
12490 arg1 = wxString_in_helper(obj0);
12491 if (arg1 == NULL) SWIG_fail;
12492 temp1 = true;
12493 }
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 wxPyLogFatalError((wxString const &)*arg1);
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 resultobj = SWIG_Py_Void();
12501 {
12502 if (temp1)
12503 delete arg1;
12504 }
12505 return resultobj;
12506 fail:
12507 {
12508 if (temp1)
12509 delete arg1;
12510 }
12511 return NULL;
12512 }
12513
12514
12515 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12516 PyObject *resultobj = 0;
12517 wxString *arg1 = 0 ;
12518 bool temp1 = false ;
12519 PyObject * obj0 = 0 ;
12520 char * kwnames[] = {
12521 (char *) "msg", NULL
12522 };
12523
12524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12525 {
12526 arg1 = wxString_in_helper(obj0);
12527 if (arg1 == NULL) SWIG_fail;
12528 temp1 = true;
12529 }
12530 {
12531 PyThreadState* __tstate = wxPyBeginAllowThreads();
12532 wxPyLogError((wxString const &)*arg1);
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 resultobj = SWIG_Py_Void();
12537 {
12538 if (temp1)
12539 delete arg1;
12540 }
12541 return resultobj;
12542 fail:
12543 {
12544 if (temp1)
12545 delete arg1;
12546 }
12547 return NULL;
12548 }
12549
12550
12551 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12552 PyObject *resultobj = 0;
12553 wxString *arg1 = 0 ;
12554 bool temp1 = false ;
12555 PyObject * obj0 = 0 ;
12556 char * kwnames[] = {
12557 (char *) "msg", NULL
12558 };
12559
12560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12561 {
12562 arg1 = wxString_in_helper(obj0);
12563 if (arg1 == NULL) SWIG_fail;
12564 temp1 = true;
12565 }
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 wxPyLogWarning((wxString const &)*arg1);
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 resultobj = SWIG_Py_Void();
12573 {
12574 if (temp1)
12575 delete arg1;
12576 }
12577 return resultobj;
12578 fail:
12579 {
12580 if (temp1)
12581 delete arg1;
12582 }
12583 return NULL;
12584 }
12585
12586
12587 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12588 PyObject *resultobj = 0;
12589 wxString *arg1 = 0 ;
12590 bool temp1 = false ;
12591 PyObject * obj0 = 0 ;
12592 char * kwnames[] = {
12593 (char *) "msg", NULL
12594 };
12595
12596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12597 {
12598 arg1 = wxString_in_helper(obj0);
12599 if (arg1 == NULL) SWIG_fail;
12600 temp1 = true;
12601 }
12602 {
12603 PyThreadState* __tstate = wxPyBeginAllowThreads();
12604 wxPyLogMessage((wxString const &)*arg1);
12605 wxPyEndAllowThreads(__tstate);
12606 if (PyErr_Occurred()) SWIG_fail;
12607 }
12608 resultobj = SWIG_Py_Void();
12609 {
12610 if (temp1)
12611 delete arg1;
12612 }
12613 return resultobj;
12614 fail:
12615 {
12616 if (temp1)
12617 delete arg1;
12618 }
12619 return NULL;
12620 }
12621
12622
12623 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12624 PyObject *resultobj = 0;
12625 wxString *arg1 = 0 ;
12626 bool temp1 = false ;
12627 PyObject * obj0 = 0 ;
12628 char * kwnames[] = {
12629 (char *) "msg", NULL
12630 };
12631
12632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12633 {
12634 arg1 = wxString_in_helper(obj0);
12635 if (arg1 == NULL) SWIG_fail;
12636 temp1 = true;
12637 }
12638 {
12639 PyThreadState* __tstate = wxPyBeginAllowThreads();
12640 wxPyLogInfo((wxString const &)*arg1);
12641 wxPyEndAllowThreads(__tstate);
12642 if (PyErr_Occurred()) SWIG_fail;
12643 }
12644 resultobj = SWIG_Py_Void();
12645 {
12646 if (temp1)
12647 delete arg1;
12648 }
12649 return resultobj;
12650 fail:
12651 {
12652 if (temp1)
12653 delete arg1;
12654 }
12655 return NULL;
12656 }
12657
12658
12659 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12660 PyObject *resultobj = 0;
12661 wxString *arg1 = 0 ;
12662 bool temp1 = false ;
12663 PyObject * obj0 = 0 ;
12664 char * kwnames[] = {
12665 (char *) "msg", NULL
12666 };
12667
12668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12669 {
12670 arg1 = wxString_in_helper(obj0);
12671 if (arg1 == NULL) SWIG_fail;
12672 temp1 = true;
12673 }
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 wxPyLogDebug((wxString const &)*arg1);
12677 wxPyEndAllowThreads(__tstate);
12678 if (PyErr_Occurred()) SWIG_fail;
12679 }
12680 resultobj = SWIG_Py_Void();
12681 {
12682 if (temp1)
12683 delete arg1;
12684 }
12685 return resultobj;
12686 fail:
12687 {
12688 if (temp1)
12689 delete arg1;
12690 }
12691 return NULL;
12692 }
12693
12694
12695 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12696 PyObject *resultobj = 0;
12697 wxString *arg1 = 0 ;
12698 bool temp1 = false ;
12699 PyObject * obj0 = 0 ;
12700 char * kwnames[] = {
12701 (char *) "msg", NULL
12702 };
12703
12704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12705 {
12706 arg1 = wxString_in_helper(obj0);
12707 if (arg1 == NULL) SWIG_fail;
12708 temp1 = true;
12709 }
12710 {
12711 PyThreadState* __tstate = wxPyBeginAllowThreads();
12712 wxPyLogVerbose((wxString const &)*arg1);
12713 wxPyEndAllowThreads(__tstate);
12714 if (PyErr_Occurred()) SWIG_fail;
12715 }
12716 resultobj = SWIG_Py_Void();
12717 {
12718 if (temp1)
12719 delete arg1;
12720 }
12721 return resultobj;
12722 fail:
12723 {
12724 if (temp1)
12725 delete arg1;
12726 }
12727 return NULL;
12728 }
12729
12730
12731 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12732 PyObject *resultobj = 0;
12733 wxString *arg1 = 0 ;
12734 bool temp1 = false ;
12735 PyObject * obj0 = 0 ;
12736 char * kwnames[] = {
12737 (char *) "msg", NULL
12738 };
12739
12740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12741 {
12742 arg1 = wxString_in_helper(obj0);
12743 if (arg1 == NULL) SWIG_fail;
12744 temp1 = true;
12745 }
12746 {
12747 PyThreadState* __tstate = wxPyBeginAllowThreads();
12748 wxPyLogStatus((wxString const &)*arg1);
12749 wxPyEndAllowThreads(__tstate);
12750 if (PyErr_Occurred()) SWIG_fail;
12751 }
12752 resultobj = SWIG_Py_Void();
12753 {
12754 if (temp1)
12755 delete arg1;
12756 }
12757 return resultobj;
12758 fail:
12759 {
12760 if (temp1)
12761 delete arg1;
12762 }
12763 return NULL;
12764 }
12765
12766
12767 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12768 PyObject *resultobj = 0;
12769 wxFrame *arg1 = (wxFrame *) 0 ;
12770 wxString *arg2 = 0 ;
12771 void *argp1 = 0 ;
12772 int res1 = 0 ;
12773 bool temp2 = false ;
12774 PyObject * obj0 = 0 ;
12775 PyObject * obj1 = 0 ;
12776 char * kwnames[] = {
12777 (char *) "pFrame",(char *) "msg", NULL
12778 };
12779
12780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12782 if (!SWIG_IsOK(res1)) {
12783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12784 }
12785 arg1 = reinterpret_cast< wxFrame * >(argp1);
12786 {
12787 arg2 = wxString_in_helper(obj1);
12788 if (arg2 == NULL) SWIG_fail;
12789 temp2 = true;
12790 }
12791 {
12792 PyThreadState* __tstate = wxPyBeginAllowThreads();
12793 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12794 wxPyEndAllowThreads(__tstate);
12795 if (PyErr_Occurred()) SWIG_fail;
12796 }
12797 resultobj = SWIG_Py_Void();
12798 {
12799 if (temp2)
12800 delete arg2;
12801 }
12802 return resultobj;
12803 fail:
12804 {
12805 if (temp2)
12806 delete arg2;
12807 }
12808 return NULL;
12809 }
12810
12811
12812 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj = 0;
12814 wxString *arg1 = 0 ;
12815 bool temp1 = false ;
12816 PyObject * obj0 = 0 ;
12817 char * kwnames[] = {
12818 (char *) "msg", NULL
12819 };
12820
12821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12822 {
12823 arg1 = wxString_in_helper(obj0);
12824 if (arg1 == NULL) SWIG_fail;
12825 temp1 = true;
12826 }
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 wxPyLogSysError((wxString const &)*arg1);
12830 wxPyEndAllowThreads(__tstate);
12831 if (PyErr_Occurred()) SWIG_fail;
12832 }
12833 resultobj = SWIG_Py_Void();
12834 {
12835 if (temp1)
12836 delete arg1;
12837 }
12838 return resultobj;
12839 fail:
12840 {
12841 if (temp1)
12842 delete arg1;
12843 }
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12849 PyObject *resultobj = 0;
12850 unsigned long arg1 ;
12851 wxString *arg2 = 0 ;
12852 unsigned long val1 ;
12853 int ecode1 = 0 ;
12854 bool temp2 = false ;
12855 PyObject * obj0 = 0 ;
12856 PyObject * obj1 = 0 ;
12857 char * kwnames[] = {
12858 (char *) "level",(char *) "msg", NULL
12859 };
12860
12861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12862 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12863 if (!SWIG_IsOK(ecode1)) {
12864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12865 }
12866 arg1 = static_cast< unsigned long >(val1);
12867 {
12868 arg2 = wxString_in_helper(obj1);
12869 if (arg2 == NULL) SWIG_fail;
12870 temp2 = true;
12871 }
12872 {
12873 PyThreadState* __tstate = wxPyBeginAllowThreads();
12874 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12875 wxPyEndAllowThreads(__tstate);
12876 if (PyErr_Occurred()) SWIG_fail;
12877 }
12878 resultobj = SWIG_Py_Void();
12879 {
12880 if (temp2)
12881 delete arg2;
12882 }
12883 return resultobj;
12884 fail:
12885 {
12886 if (temp2)
12887 delete arg2;
12888 }
12889 return NULL;
12890 }
12891
12892
12893 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12894 PyObject *resultobj = 0;
12895 unsigned long arg1 ;
12896 wxString *arg2 = 0 ;
12897 unsigned long val1 ;
12898 int ecode1 = 0 ;
12899 bool temp2 = false ;
12900
12901 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12902 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12903 if (!SWIG_IsOK(ecode1)) {
12904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12905 }
12906 arg1 = static_cast< unsigned long >(val1);
12907 {
12908 arg2 = wxString_in_helper(swig_obj[1]);
12909 if (arg2 == NULL) SWIG_fail;
12910 temp2 = true;
12911 }
12912 {
12913 PyThreadState* __tstate = wxPyBeginAllowThreads();
12914 wxPyLogTrace(arg1,(wxString const &)*arg2);
12915 wxPyEndAllowThreads(__tstate);
12916 if (PyErr_Occurred()) SWIG_fail;
12917 }
12918 resultobj = SWIG_Py_Void();
12919 {
12920 if (temp2)
12921 delete arg2;
12922 }
12923 return resultobj;
12924 fail:
12925 {
12926 if (temp2)
12927 delete arg2;
12928 }
12929 return NULL;
12930 }
12931
12932
12933 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12934 PyObject *resultobj = 0;
12935 wxString *arg1 = 0 ;
12936 wxString *arg2 = 0 ;
12937 bool temp1 = false ;
12938 bool temp2 = false ;
12939
12940 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12941 {
12942 arg1 = wxString_in_helper(swig_obj[0]);
12943 if (arg1 == NULL) SWIG_fail;
12944 temp1 = true;
12945 }
12946 {
12947 arg2 = wxString_in_helper(swig_obj[1]);
12948 if (arg2 == NULL) SWIG_fail;
12949 temp2 = true;
12950 }
12951 {
12952 PyThreadState* __tstate = wxPyBeginAllowThreads();
12953 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12954 wxPyEndAllowThreads(__tstate);
12955 if (PyErr_Occurred()) SWIG_fail;
12956 }
12957 resultobj = SWIG_Py_Void();
12958 {
12959 if (temp1)
12960 delete arg1;
12961 }
12962 {
12963 if (temp2)
12964 delete arg2;
12965 }
12966 return resultobj;
12967 fail:
12968 {
12969 if (temp1)
12970 delete arg1;
12971 }
12972 {
12973 if (temp2)
12974 delete arg2;
12975 }
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12981 int argc;
12982 PyObject *argv[3];
12983
12984 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12985 --argc;
12986 if (argc == 2) {
12987 int _v = 0;
12988 {
12989 {
12990 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12991 }
12992 }
12993 if (!_v) goto check_1;
12994 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12995 }
12996 check_1:
12997
12998 if (argc == 2) {
12999 return _wrap_LogTrace__SWIG_0(self, argc, argv);
13000 }
13001
13002 fail:
13003 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
13004 return NULL;
13005 }
13006
13007
13008 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13009 PyObject *resultobj = 0;
13010 wxString *arg1 = 0 ;
13011 wxString *arg2 = 0 ;
13012 bool temp1 = false ;
13013 bool temp2 = false ;
13014 PyObject * obj0 = 0 ;
13015 PyObject * obj1 = 0 ;
13016 char * kwnames[] = {
13017 (char *) "title",(char *) "text", NULL
13018 };
13019
13020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13021 {
13022 arg1 = wxString_in_helper(obj0);
13023 if (arg1 == NULL) SWIG_fail;
13024 temp1 = true;
13025 }
13026 {
13027 arg2 = wxString_in_helper(obj1);
13028 if (arg2 == NULL) SWIG_fail;
13029 temp2 = true;
13030 }
13031 {
13032 PyThreadState* __tstate = wxPyBeginAllowThreads();
13033 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13034 wxPyEndAllowThreads(__tstate);
13035 if (PyErr_Occurred()) SWIG_fail;
13036 }
13037 resultobj = SWIG_Py_Void();
13038 {
13039 if (temp1)
13040 delete arg1;
13041 }
13042 {
13043 if (temp2)
13044 delete arg2;
13045 }
13046 return resultobj;
13047 fail:
13048 {
13049 if (temp1)
13050 delete arg1;
13051 }
13052 {
13053 if (temp2)
13054 delete arg2;
13055 }
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061 PyObject *resultobj = 0;
13062 wxLogNull *result = 0 ;
13063
13064 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = (wxLogNull *)new wxLogNull();
13068 wxPyEndAllowThreads(__tstate);
13069 if (PyErr_Occurred()) SWIG_fail;
13070 }
13071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13072 return resultobj;
13073 fail:
13074 return NULL;
13075 }
13076
13077
13078 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13079 PyObject *resultobj = 0;
13080 wxLogNull *arg1 = (wxLogNull *) 0 ;
13081 void *argp1 = 0 ;
13082 int res1 = 0 ;
13083 PyObject *swig_obj[1] ;
13084
13085 if (!args) SWIG_fail;
13086 swig_obj[0] = args;
13087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13088 if (!SWIG_IsOK(res1)) {
13089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13090 }
13091 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 delete arg1;
13095
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 resultobj = SWIG_Py_Void();
13100 return resultobj;
13101 fail:
13102 return NULL;
13103 }
13104
13105
13106 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13107 PyObject *obj;
13108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13109 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13110 return SWIG_Py_Void();
13111 }
13112
13113 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114 return SWIG_Python_InitShadowInstance(args);
13115 }
13116
13117 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13118 PyObject *resultobj = 0;
13119 wxPyLog *result = 0 ;
13120
13121 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 result = (wxPyLog *)new wxPyLog();
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
13129 return resultobj;
13130 fail:
13131 return NULL;
13132 }
13133
13134
13135 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj = 0;
13137 wxPyLog *arg1 = (wxPyLog *) 0 ;
13138 PyObject *arg2 = (PyObject *) 0 ;
13139 PyObject *arg3 = (PyObject *) 0 ;
13140 void *argp1 = 0 ;
13141 int res1 = 0 ;
13142 PyObject * obj0 = 0 ;
13143 PyObject * obj1 = 0 ;
13144 PyObject * obj2 = 0 ;
13145 char * kwnames[] = {
13146 (char *) "self",(char *) "self",(char *) "_class", NULL
13147 };
13148
13149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
13151 if (!SWIG_IsOK(res1)) {
13152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
13153 }
13154 arg1 = reinterpret_cast< wxPyLog * >(argp1);
13155 arg2 = obj1;
13156 arg3 = obj2;
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 (arg1)->_setCallbackInfo(arg2,arg3);
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 resultobj = SWIG_Py_Void();
13164 return resultobj;
13165 fail:
13166 return NULL;
13167 }
13168
13169
13170 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13171 PyObject *obj;
13172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13173 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
13174 return SWIG_Py_Void();
13175 }
13176
13177 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13178 return SWIG_Python_InitShadowInstance(args);
13179 }
13180
13181 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13182 PyObject *resultobj = 0;
13183 int arg1 ;
13184 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13185 int arg3 = (int) wxKILL_NOCHILDREN ;
13186 wxKillError result;
13187 int val1 ;
13188 int ecode1 = 0 ;
13189 int val2 ;
13190 int ecode2 = 0 ;
13191 int val3 ;
13192 int ecode3 = 0 ;
13193 PyObject * obj0 = 0 ;
13194 PyObject * obj1 = 0 ;
13195 PyObject * obj2 = 0 ;
13196 char * kwnames[] = {
13197 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13198 };
13199
13200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13201 ecode1 = SWIG_AsVal_int(obj0, &val1);
13202 if (!SWIG_IsOK(ecode1)) {
13203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13204 }
13205 arg1 = static_cast< int >(val1);
13206 if (obj1) {
13207 ecode2 = SWIG_AsVal_int(obj1, &val2);
13208 if (!SWIG_IsOK(ecode2)) {
13209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13210 }
13211 arg2 = static_cast< wxSignal >(val2);
13212 }
13213 if (obj2) {
13214 ecode3 = SWIG_AsVal_int(obj2, &val3);
13215 if (!SWIG_IsOK(ecode3)) {
13216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13217 }
13218 arg3 = static_cast< int >(val3);
13219 }
13220 {
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 resultobj = SWIG_From_int(static_cast< int >(result));
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj = 0;
13235 int arg1 ;
13236 bool result;
13237 int val1 ;
13238 int ecode1 = 0 ;
13239 PyObject * obj0 = 0 ;
13240 char * kwnames[] = {
13241 (char *) "pid", NULL
13242 };
13243
13244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13245 ecode1 = SWIG_AsVal_int(obj0, &val1);
13246 if (!SWIG_IsOK(ecode1)) {
13247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13248 }
13249 arg1 = static_cast< int >(val1);
13250 {
13251 PyThreadState* __tstate = wxPyBeginAllowThreads();
13252 result = (bool)wxPyProcess::Exists(arg1);
13253 wxPyEndAllowThreads(__tstate);
13254 if (PyErr_Occurred()) SWIG_fail;
13255 }
13256 {
13257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13258 }
13259 return resultobj;
13260 fail:
13261 return NULL;
13262 }
13263
13264
13265 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13266 PyObject *resultobj = 0;
13267 wxString *arg1 = 0 ;
13268 int arg2 = (int) wxEXEC_ASYNC ;
13269 wxPyProcess *result = 0 ;
13270 bool temp1 = false ;
13271 int val2 ;
13272 int ecode2 = 0 ;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 char * kwnames[] = {
13276 (char *) "cmd",(char *) "flags", NULL
13277 };
13278
13279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13280 {
13281 arg1 = wxString_in_helper(obj0);
13282 if (arg1 == NULL) SWIG_fail;
13283 temp1 = true;
13284 }
13285 if (obj1) {
13286 ecode2 = SWIG_AsVal_int(obj1, &val2);
13287 if (!SWIG_IsOK(ecode2)) {
13288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13289 }
13290 arg2 = static_cast< int >(val2);
13291 }
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13295 wxPyEndAllowThreads(__tstate);
13296 if (PyErr_Occurred()) SWIG_fail;
13297 }
13298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13299 {
13300 if (temp1)
13301 delete arg1;
13302 }
13303 return resultobj;
13304 fail:
13305 {
13306 if (temp1)
13307 delete arg1;
13308 }
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13314 PyObject *resultobj = 0;
13315 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13316 int arg2 = (int) -1 ;
13317 wxPyProcess *result = 0 ;
13318 void *argp1 = 0 ;
13319 int res1 = 0 ;
13320 int val2 ;
13321 int ecode2 = 0 ;
13322 PyObject * obj0 = 0 ;
13323 PyObject * obj1 = 0 ;
13324 char * kwnames[] = {
13325 (char *) "parent",(char *) "id", NULL
13326 };
13327
13328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13329 if (obj0) {
13330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13331 if (!SWIG_IsOK(res1)) {
13332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13333 }
13334 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13335 }
13336 if (obj1) {
13337 ecode2 = SWIG_AsVal_int(obj1, &val2);
13338 if (!SWIG_IsOK(ecode2)) {
13339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13340 }
13341 arg2 = static_cast< int >(val2);
13342 }
13343 {
13344 PyThreadState* __tstate = wxPyBeginAllowThreads();
13345 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13346 wxPyEndAllowThreads(__tstate);
13347 if (PyErr_Occurred()) SWIG_fail;
13348 }
13349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13350 return resultobj;
13351 fail:
13352 return NULL;
13353 }
13354
13355
13356 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13357 PyObject *resultobj = 0;
13358 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13359 PyObject *arg2 = (PyObject *) 0 ;
13360 PyObject *arg3 = (PyObject *) 0 ;
13361 void *argp1 = 0 ;
13362 int res1 = 0 ;
13363 PyObject * obj0 = 0 ;
13364 PyObject * obj1 = 0 ;
13365 PyObject * obj2 = 0 ;
13366 char * kwnames[] = {
13367 (char *) "self",(char *) "self",(char *) "_class", NULL
13368 };
13369
13370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13372 if (!SWIG_IsOK(res1)) {
13373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13374 }
13375 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13376 arg2 = obj1;
13377 arg3 = obj2;
13378 {
13379 PyThreadState* __tstate = wxPyBeginAllowThreads();
13380 (arg1)->_setCallbackInfo(arg2,arg3);
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 resultobj = SWIG_Py_Void();
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13392 PyObject *resultobj = 0;
13393 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13394 int arg2 ;
13395 int arg3 ;
13396 void *argp1 = 0 ;
13397 int res1 = 0 ;
13398 int val2 ;
13399 int ecode2 = 0 ;
13400 int val3 ;
13401 int ecode3 = 0 ;
13402 PyObject * obj0 = 0 ;
13403 PyObject * obj1 = 0 ;
13404 PyObject * obj2 = 0 ;
13405 char * kwnames[] = {
13406 (char *) "self",(char *) "pid",(char *) "status", NULL
13407 };
13408
13409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13411 if (!SWIG_IsOK(res1)) {
13412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13413 }
13414 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13415 ecode2 = SWIG_AsVal_int(obj1, &val2);
13416 if (!SWIG_IsOK(ecode2)) {
13417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13418 }
13419 arg2 = static_cast< int >(val2);
13420 ecode3 = SWIG_AsVal_int(obj2, &val3);
13421 if (!SWIG_IsOK(ecode3)) {
13422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13423 }
13424 arg3 = static_cast< int >(val3);
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 (arg1)->OnTerminate(arg2,arg3);
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 resultobj = SWIG_Py_Void();
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *resultobj = 0;
13440 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13441 void *argp1 = 0 ;
13442 int res1 = 0 ;
13443 PyObject *swig_obj[1] ;
13444
13445 if (!args) SWIG_fail;
13446 swig_obj[0] = args;
13447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13448 if (!SWIG_IsOK(res1)) {
13449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13450 }
13451 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 (arg1)->Redirect();
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 resultobj = SWIG_Py_Void();
13459 return resultobj;
13460 fail:
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13466 PyObject *resultobj = 0;
13467 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13468 bool result;
13469 void *argp1 = 0 ;
13470 int res1 = 0 ;
13471 PyObject *swig_obj[1] ;
13472
13473 if (!args) SWIG_fail;
13474 swig_obj[0] = args;
13475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13476 if (!SWIG_IsOK(res1)) {
13477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13478 }
13479 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13480 {
13481 PyThreadState* __tstate = wxPyBeginAllowThreads();
13482 result = (bool)(arg1)->IsRedirected();
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 {
13487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13488 }
13489 return resultobj;
13490 fail:
13491 return NULL;
13492 }
13493
13494
13495 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13496 PyObject *resultobj = 0;
13497 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13498 void *argp1 = 0 ;
13499 int res1 = 0 ;
13500 PyObject *swig_obj[1] ;
13501
13502 if (!args) SWIG_fail;
13503 swig_obj[0] = args;
13504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13505 if (!SWIG_IsOK(res1)) {
13506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13507 }
13508 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13509 {
13510 PyThreadState* __tstate = wxPyBeginAllowThreads();
13511 (arg1)->Detach();
13512 wxPyEndAllowThreads(__tstate);
13513 if (PyErr_Occurred()) SWIG_fail;
13514 }
13515 resultobj = SWIG_Py_Void();
13516 return resultobj;
13517 fail:
13518 return NULL;
13519 }
13520
13521
13522 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13523 PyObject *resultobj = 0;
13524 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13525 wxInputStream *result = 0 ;
13526 void *argp1 = 0 ;
13527 int res1 = 0 ;
13528 PyObject *swig_obj[1] ;
13529
13530 if (!args) SWIG_fail;
13531 swig_obj[0] = args;
13532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13533 if (!SWIG_IsOK(res1)) {
13534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13535 }
13536 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13537 {
13538 PyThreadState* __tstate = wxPyBeginAllowThreads();
13539 result = (wxInputStream *)(arg1)->GetInputStream();
13540 wxPyEndAllowThreads(__tstate);
13541 if (PyErr_Occurred()) SWIG_fail;
13542 }
13543 {
13544 wxPyInputStream * _ptr = NULL;
13545
13546 if (result) {
13547 _ptr = new wxPyInputStream(result);
13548 }
13549 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13550 }
13551 return resultobj;
13552 fail:
13553 return NULL;
13554 }
13555
13556
13557 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13558 PyObject *resultobj = 0;
13559 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13560 wxInputStream *result = 0 ;
13561 void *argp1 = 0 ;
13562 int res1 = 0 ;
13563 PyObject *swig_obj[1] ;
13564
13565 if (!args) SWIG_fail;
13566 swig_obj[0] = args;
13567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13568 if (!SWIG_IsOK(res1)) {
13569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13570 }
13571 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13572 {
13573 PyThreadState* __tstate = wxPyBeginAllowThreads();
13574 result = (wxInputStream *)(arg1)->GetErrorStream();
13575 wxPyEndAllowThreads(__tstate);
13576 if (PyErr_Occurred()) SWIG_fail;
13577 }
13578 {
13579 wxPyInputStream * _ptr = NULL;
13580
13581 if (result) {
13582 _ptr = new wxPyInputStream(result);
13583 }
13584 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13585 }
13586 return resultobj;
13587 fail:
13588 return NULL;
13589 }
13590
13591
13592 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13593 PyObject *resultobj = 0;
13594 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13595 wxOutputStream *result = 0 ;
13596 void *argp1 = 0 ;
13597 int res1 = 0 ;
13598 PyObject *swig_obj[1] ;
13599
13600 if (!args) SWIG_fail;
13601 swig_obj[0] = args;
13602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13603 if (!SWIG_IsOK(res1)) {
13604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13605 }
13606 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13607 {
13608 PyThreadState* __tstate = wxPyBeginAllowThreads();
13609 result = (wxOutputStream *)(arg1)->GetOutputStream();
13610 wxPyEndAllowThreads(__tstate);
13611 if (PyErr_Occurred()) SWIG_fail;
13612 }
13613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13614 return resultobj;
13615 fail:
13616 return NULL;
13617 }
13618
13619
13620 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13621 PyObject *resultobj = 0;
13622 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13623 void *argp1 = 0 ;
13624 int res1 = 0 ;
13625 PyObject *swig_obj[1] ;
13626
13627 if (!args) SWIG_fail;
13628 swig_obj[0] = args;
13629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13630 if (!SWIG_IsOK(res1)) {
13631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13632 }
13633 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13634 {
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 (arg1)->CloseOutput();
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 resultobj = SWIG_Py_Void();
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13648 PyObject *resultobj = 0;
13649 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13650 bool result;
13651 void *argp1 = 0 ;
13652 int res1 = 0 ;
13653 PyObject *swig_obj[1] ;
13654
13655 if (!args) SWIG_fail;
13656 swig_obj[0] = args;
13657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13658 if (!SWIG_IsOK(res1)) {
13659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13660 }
13661 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13662 {
13663 PyThreadState* __tstate = wxPyBeginAllowThreads();
13664 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13665 wxPyEndAllowThreads(__tstate);
13666 if (PyErr_Occurred()) SWIG_fail;
13667 }
13668 {
13669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13670 }
13671 return resultobj;
13672 fail:
13673 return NULL;
13674 }
13675
13676
13677 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13678 PyObject *resultobj = 0;
13679 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13680 bool result;
13681 void *argp1 = 0 ;
13682 int res1 = 0 ;
13683 PyObject *swig_obj[1] ;
13684
13685 if (!args) SWIG_fail;
13686 swig_obj[0] = args;
13687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13688 if (!SWIG_IsOK(res1)) {
13689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13690 }
13691 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13692 {
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13695 wxPyEndAllowThreads(__tstate);
13696 if (PyErr_Occurred()) SWIG_fail;
13697 }
13698 {
13699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13700 }
13701 return resultobj;
13702 fail:
13703 return NULL;
13704 }
13705
13706
13707 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13708 PyObject *resultobj = 0;
13709 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13710 bool result;
13711 void *argp1 = 0 ;
13712 int res1 = 0 ;
13713 PyObject *swig_obj[1] ;
13714
13715 if (!args) SWIG_fail;
13716 swig_obj[0] = args;
13717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13718 if (!SWIG_IsOK(res1)) {
13719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13720 }
13721 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13722 {
13723 PyThreadState* __tstate = wxPyBeginAllowThreads();
13724 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 {
13729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13730 }
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13738 PyObject *obj;
13739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13740 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13741 return SWIG_Py_Void();
13742 }
13743
13744 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13745 return SWIG_Python_InitShadowInstance(args);
13746 }
13747
13748 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13749 PyObject *resultobj = 0;
13750 int arg1 = (int) 0 ;
13751 int arg2 = (int) 0 ;
13752 int arg3 = (int) 0 ;
13753 wxProcessEvent *result = 0 ;
13754 int val1 ;
13755 int ecode1 = 0 ;
13756 int val2 ;
13757 int ecode2 = 0 ;
13758 int val3 ;
13759 int ecode3 = 0 ;
13760 PyObject * obj0 = 0 ;
13761 PyObject * obj1 = 0 ;
13762 PyObject * obj2 = 0 ;
13763 char * kwnames[] = {
13764 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13765 };
13766
13767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13768 if (obj0) {
13769 ecode1 = SWIG_AsVal_int(obj0, &val1);
13770 if (!SWIG_IsOK(ecode1)) {
13771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13772 }
13773 arg1 = static_cast< int >(val1);
13774 }
13775 if (obj1) {
13776 ecode2 = SWIG_AsVal_int(obj1, &val2);
13777 if (!SWIG_IsOK(ecode2)) {
13778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13779 }
13780 arg2 = static_cast< int >(val2);
13781 }
13782 if (obj2) {
13783 ecode3 = SWIG_AsVal_int(obj2, &val3);
13784 if (!SWIG_IsOK(ecode3)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13786 }
13787 arg3 = static_cast< int >(val3);
13788 }
13789 {
13790 PyThreadState* __tstate = wxPyBeginAllowThreads();
13791 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13796 return resultobj;
13797 fail:
13798 return NULL;
13799 }
13800
13801
13802 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13803 PyObject *resultobj = 0;
13804 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13805 int result;
13806 void *argp1 = 0 ;
13807 int res1 = 0 ;
13808 PyObject *swig_obj[1] ;
13809
13810 if (!args) SWIG_fail;
13811 swig_obj[0] = args;
13812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13813 if (!SWIG_IsOK(res1)) {
13814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13815 }
13816 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13817 {
13818 PyThreadState* __tstate = wxPyBeginAllowThreads();
13819 result = (int)(arg1)->GetPid();
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 resultobj = SWIG_From_int(static_cast< int >(result));
13824 return resultobj;
13825 fail:
13826 return NULL;
13827 }
13828
13829
13830 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13831 PyObject *resultobj = 0;
13832 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13833 int result;
13834 void *argp1 = 0 ;
13835 int res1 = 0 ;
13836 PyObject *swig_obj[1] ;
13837
13838 if (!args) SWIG_fail;
13839 swig_obj[0] = args;
13840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13841 if (!SWIG_IsOK(res1)) {
13842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13843 }
13844 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 result = (int)(arg1)->GetExitCode();
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_From_int(static_cast< int >(result));
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13859 PyObject *resultobj = 0;
13860 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13861 int arg2 ;
13862 void *argp1 = 0 ;
13863 int res1 = 0 ;
13864 int val2 ;
13865 int ecode2 = 0 ;
13866 PyObject *swig_obj[2] ;
13867
13868 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13870 if (!SWIG_IsOK(res1)) {
13871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13872 }
13873 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13874 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13875 if (!SWIG_IsOK(ecode2)) {
13876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13877 }
13878 arg2 = static_cast< int >(val2);
13879 if (arg1) (arg1)->m_pid = arg2;
13880
13881 resultobj = SWIG_Py_Void();
13882 return resultobj;
13883 fail:
13884 return NULL;
13885 }
13886
13887
13888 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13889 PyObject *resultobj = 0;
13890 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13891 int result;
13892 void *argp1 = 0 ;
13893 int res1 = 0 ;
13894 PyObject *swig_obj[1] ;
13895
13896 if (!args) SWIG_fail;
13897 swig_obj[0] = args;
13898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13899 if (!SWIG_IsOK(res1)) {
13900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13901 }
13902 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13903 result = (int) ((arg1)->m_pid);
13904 resultobj = SWIG_From_int(static_cast< int >(result));
13905 return resultobj;
13906 fail:
13907 return NULL;
13908 }
13909
13910
13911 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13912 PyObject *resultobj = 0;
13913 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13914 int arg2 ;
13915 void *argp1 = 0 ;
13916 int res1 = 0 ;
13917 int val2 ;
13918 int ecode2 = 0 ;
13919 PyObject *swig_obj[2] ;
13920
13921 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13923 if (!SWIG_IsOK(res1)) {
13924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13925 }
13926 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13927 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13928 if (!SWIG_IsOK(ecode2)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13930 }
13931 arg2 = static_cast< int >(val2);
13932 if (arg1) (arg1)->m_exitcode = arg2;
13933
13934 resultobj = SWIG_Py_Void();
13935 return resultobj;
13936 fail:
13937 return NULL;
13938 }
13939
13940
13941 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13942 PyObject *resultobj = 0;
13943 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13944 int result;
13945 void *argp1 = 0 ;
13946 int res1 = 0 ;
13947 PyObject *swig_obj[1] ;
13948
13949 if (!args) SWIG_fail;
13950 swig_obj[0] = args;
13951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13952 if (!SWIG_IsOK(res1)) {
13953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13954 }
13955 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13956 result = (int) ((arg1)->m_exitcode);
13957 resultobj = SWIG_From_int(static_cast< int >(result));
13958 return resultobj;
13959 fail:
13960 return NULL;
13961 }
13962
13963
13964 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13965 PyObject *obj;
13966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13967 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13968 return SWIG_Py_Void();
13969 }
13970
13971 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13972 return SWIG_Python_InitShadowInstance(args);
13973 }
13974
13975 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13976 PyObject *resultobj = 0;
13977 wxString *arg1 = 0 ;
13978 int arg2 = (int) wxEXEC_ASYNC ;
13979 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13980 long result;
13981 bool temp1 = false ;
13982 int val2 ;
13983 int ecode2 = 0 ;
13984 void *argp3 = 0 ;
13985 int res3 = 0 ;
13986 PyObject * obj0 = 0 ;
13987 PyObject * obj1 = 0 ;
13988 PyObject * obj2 = 0 ;
13989 char * kwnames[] = {
13990 (char *) "command",(char *) "flags",(char *) "process", NULL
13991 };
13992
13993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13994 {
13995 arg1 = wxString_in_helper(obj0);
13996 if (arg1 == NULL) SWIG_fail;
13997 temp1 = true;
13998 }
13999 if (obj1) {
14000 ecode2 = SWIG_AsVal_int(obj1, &val2);
14001 if (!SWIG_IsOK(ecode2)) {
14002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
14003 }
14004 arg2 = static_cast< int >(val2);
14005 }
14006 if (obj2) {
14007 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14008 if (!SWIG_IsOK(res3)) {
14009 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14010 }
14011 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14012 }
14013 {
14014 if (!wxPyCheckForApp()) SWIG_fail;
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14017 wxPyEndAllowThreads(__tstate);
14018 if (PyErr_Occurred()) SWIG_fail;
14019 }
14020 resultobj = SWIG_From_long(static_cast< long >(result));
14021 {
14022 if (temp1)
14023 delete arg1;
14024 }
14025 return resultobj;
14026 fail:
14027 {
14028 if (temp1)
14029 delete arg1;
14030 }
14031 return NULL;
14032 }
14033
14034
14035 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj = 0;
14037 long arg1 ;
14038 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14039 wxKillError *arg3 = (wxKillError *) 0 ;
14040 int arg4 = (int) wxKILL_NOCHILDREN ;
14041 int result;
14042 long val1 ;
14043 int ecode1 = 0 ;
14044 int val2 ;
14045 int ecode2 = 0 ;
14046 wxKillError temp3 ;
14047 int val4 ;
14048 int ecode4 = 0 ;
14049 PyObject * obj0 = 0 ;
14050 PyObject * obj1 = 0 ;
14051 PyObject * obj2 = 0 ;
14052 char * kwnames[] = {
14053 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14054 };
14055
14056 {
14057 arg3 = &temp3;
14058 }
14059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14060 ecode1 = SWIG_AsVal_long(obj0, &val1);
14061 if (!SWIG_IsOK(ecode1)) {
14062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14063 }
14064 arg1 = static_cast< long >(val1);
14065 if (obj1) {
14066 ecode2 = SWIG_AsVal_int(obj1, &val2);
14067 if (!SWIG_IsOK(ecode2)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14069 }
14070 arg2 = static_cast< wxSignal >(val2);
14071 }
14072 if (obj2) {
14073 ecode4 = SWIG_AsVal_int(obj2, &val4);
14074 if (!SWIG_IsOK(ecode4)) {
14075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14076 }
14077 arg4 = static_cast< int >(val4);
14078 }
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 result = (int)wxKill(arg1,arg2,arg3,arg4);
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 resultobj = SWIG_From_int(static_cast< int >(result));
14086 {
14087 PyObject* o;
14088 o = PyInt_FromLong((long) (*arg3));
14089
14090
14091
14092 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14093
14094 }
14095 return resultobj;
14096 fail:
14097 return NULL;
14098 }
14099
14100
14101 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14102 PyObject *resultobj = 0;
14103 int arg1 = (int) wxJOYSTICK1 ;
14104 wxJoystick *result = 0 ;
14105 int val1 ;
14106 int ecode1 = 0 ;
14107 PyObject * obj0 = 0 ;
14108 char * kwnames[] = {
14109 (char *) "joystick", NULL
14110 };
14111
14112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14113 if (obj0) {
14114 ecode1 = SWIG_AsVal_int(obj0, &val1);
14115 if (!SWIG_IsOK(ecode1)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
14117 }
14118 arg1 = static_cast< int >(val1);
14119 }
14120 {
14121 if (!wxPyCheckForApp()) SWIG_fail;
14122 PyThreadState* __tstate = wxPyBeginAllowThreads();
14123 result = (wxJoystick *)new wxJoystick(arg1);
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14135 PyObject *resultobj = 0;
14136 wxJoystick *arg1 = (wxJoystick *) 0 ;
14137 void *argp1 = 0 ;
14138 int res1 = 0 ;
14139 PyObject *swig_obj[1] ;
14140
14141 if (!args) SWIG_fail;
14142 swig_obj[0] = args;
14143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
14144 if (!SWIG_IsOK(res1)) {
14145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
14146 }
14147 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14148 {
14149 PyThreadState* __tstate = wxPyBeginAllowThreads();
14150 delete arg1;
14151
14152 wxPyEndAllowThreads(__tstate);
14153 if (PyErr_Occurred()) SWIG_fail;
14154 }
14155 resultobj = SWIG_Py_Void();
14156 return resultobj;
14157 fail:
14158 return NULL;
14159 }
14160
14161
14162 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14163 PyObject *resultobj = 0;
14164 wxJoystick *arg1 = (wxJoystick *) 0 ;
14165 wxPoint result;
14166 void *argp1 = 0 ;
14167 int res1 = 0 ;
14168 PyObject *swig_obj[1] ;
14169
14170 if (!args) SWIG_fail;
14171 swig_obj[0] = args;
14172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14173 if (!SWIG_IsOK(res1)) {
14174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14175 }
14176 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 result = (arg1)->GetPosition();
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14191 PyObject *resultobj = 0;
14192 wxJoystick *arg1 = (wxJoystick *) 0 ;
14193 int result;
14194 void *argp1 = 0 ;
14195 int res1 = 0 ;
14196 PyObject *swig_obj[1] ;
14197
14198 if (!args) SWIG_fail;
14199 swig_obj[0] = args;
14200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14201 if (!SWIG_IsOK(res1)) {
14202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14203 }
14204 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 result = (int)(arg1)->GetZPosition();
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 resultobj = SWIG_From_int(static_cast< int >(result));
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14219 PyObject *resultobj = 0;
14220 wxJoystick *arg1 = (wxJoystick *) 0 ;
14221 int result;
14222 void *argp1 = 0 ;
14223 int res1 = 0 ;
14224 PyObject *swig_obj[1] ;
14225
14226 if (!args) SWIG_fail;
14227 swig_obj[0] = args;
14228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14229 if (!SWIG_IsOK(res1)) {
14230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14231 }
14232 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 result = (int)(arg1)->GetButtonState();
14236 wxPyEndAllowThreads(__tstate);
14237 if (PyErr_Occurred()) SWIG_fail;
14238 }
14239 resultobj = SWIG_From_int(static_cast< int >(result));
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14247 PyObject *resultobj = 0;
14248 wxJoystick *arg1 = (wxJoystick *) 0 ;
14249 int result;
14250 void *argp1 = 0 ;
14251 int res1 = 0 ;
14252 PyObject *swig_obj[1] ;
14253
14254 if (!args) SWIG_fail;
14255 swig_obj[0] = args;
14256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14257 if (!SWIG_IsOK(res1)) {
14258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14259 }
14260 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14261 {
14262 PyThreadState* __tstate = wxPyBeginAllowThreads();
14263 result = (int)(arg1)->GetPOVPosition();
14264 wxPyEndAllowThreads(__tstate);
14265 if (PyErr_Occurred()) SWIG_fail;
14266 }
14267 resultobj = SWIG_From_int(static_cast< int >(result));
14268 return resultobj;
14269 fail:
14270 return NULL;
14271 }
14272
14273
14274 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14275 PyObject *resultobj = 0;
14276 wxJoystick *arg1 = (wxJoystick *) 0 ;
14277 int result;
14278 void *argp1 = 0 ;
14279 int res1 = 0 ;
14280 PyObject *swig_obj[1] ;
14281
14282 if (!args) SWIG_fail;
14283 swig_obj[0] = args;
14284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14285 if (!SWIG_IsOK(res1)) {
14286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14287 }
14288 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 result = (int)(arg1)->GetPOVCTSPosition();
14292 wxPyEndAllowThreads(__tstate);
14293 if (PyErr_Occurred()) SWIG_fail;
14294 }
14295 resultobj = SWIG_From_int(static_cast< int >(result));
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14303 PyObject *resultobj = 0;
14304 wxJoystick *arg1 = (wxJoystick *) 0 ;
14305 int result;
14306 void *argp1 = 0 ;
14307 int res1 = 0 ;
14308 PyObject *swig_obj[1] ;
14309
14310 if (!args) SWIG_fail;
14311 swig_obj[0] = args;
14312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14313 if (!SWIG_IsOK(res1)) {
14314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14315 }
14316 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (int)(arg1)->GetRudderPosition();
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 resultobj = SWIG_From_int(static_cast< int >(result));
14324 return resultobj;
14325 fail:
14326 return NULL;
14327 }
14328
14329
14330 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14331 PyObject *resultobj = 0;
14332 wxJoystick *arg1 = (wxJoystick *) 0 ;
14333 int result;
14334 void *argp1 = 0 ;
14335 int res1 = 0 ;
14336 PyObject *swig_obj[1] ;
14337
14338 if (!args) SWIG_fail;
14339 swig_obj[0] = args;
14340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14341 if (!SWIG_IsOK(res1)) {
14342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14343 }
14344 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 result = (int)(arg1)->GetUPosition();
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 resultobj = SWIG_From_int(static_cast< int >(result));
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14359 PyObject *resultobj = 0;
14360 wxJoystick *arg1 = (wxJoystick *) 0 ;
14361 int result;
14362 void *argp1 = 0 ;
14363 int res1 = 0 ;
14364 PyObject *swig_obj[1] ;
14365
14366 if (!args) SWIG_fail;
14367 swig_obj[0] = args;
14368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14369 if (!SWIG_IsOK(res1)) {
14370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14371 }
14372 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 result = (int)(arg1)->GetVPosition();
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 resultobj = SWIG_From_int(static_cast< int >(result));
14380 return resultobj;
14381 fail:
14382 return NULL;
14383 }
14384
14385
14386 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14387 PyObject *resultobj = 0;
14388 wxJoystick *arg1 = (wxJoystick *) 0 ;
14389 int result;
14390 void *argp1 = 0 ;
14391 int res1 = 0 ;
14392 PyObject *swig_obj[1] ;
14393
14394 if (!args) SWIG_fail;
14395 swig_obj[0] = args;
14396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14397 if (!SWIG_IsOK(res1)) {
14398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14399 }
14400 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14401 {
14402 PyThreadState* __tstate = wxPyBeginAllowThreads();
14403 result = (int)(arg1)->GetMovementThreshold();
14404 wxPyEndAllowThreads(__tstate);
14405 if (PyErr_Occurred()) SWIG_fail;
14406 }
14407 resultobj = SWIG_From_int(static_cast< int >(result));
14408 return resultobj;
14409 fail:
14410 return NULL;
14411 }
14412
14413
14414 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14415 PyObject *resultobj = 0;
14416 wxJoystick *arg1 = (wxJoystick *) 0 ;
14417 int arg2 ;
14418 void *argp1 = 0 ;
14419 int res1 = 0 ;
14420 int val2 ;
14421 int ecode2 = 0 ;
14422 PyObject * obj0 = 0 ;
14423 PyObject * obj1 = 0 ;
14424 char * kwnames[] = {
14425 (char *) "self",(char *) "threshold", NULL
14426 };
14427
14428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14430 if (!SWIG_IsOK(res1)) {
14431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14432 }
14433 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14434 ecode2 = SWIG_AsVal_int(obj1, &val2);
14435 if (!SWIG_IsOK(ecode2)) {
14436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14437 }
14438 arg2 = static_cast< int >(val2);
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 (arg1)->SetMovementThreshold(arg2);
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 resultobj = SWIG_Py_Void();
14446 return resultobj;
14447 fail:
14448 return NULL;
14449 }
14450
14451
14452 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14453 PyObject *resultobj = 0;
14454 wxJoystick *arg1 = (wxJoystick *) 0 ;
14455 bool result;
14456 void *argp1 = 0 ;
14457 int res1 = 0 ;
14458 PyObject *swig_obj[1] ;
14459
14460 if (!args) SWIG_fail;
14461 swig_obj[0] = args;
14462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14463 if (!SWIG_IsOK(res1)) {
14464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14465 }
14466 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (bool)(arg1)->IsOk();
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 {
14474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14475 }
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14483 PyObject *resultobj = 0;
14484 wxJoystick *arg1 = (wxJoystick *) 0 ;
14485 int result;
14486 void *argp1 = 0 ;
14487 int res1 = 0 ;
14488 PyObject *swig_obj[1] ;
14489
14490 if (!args) SWIG_fail;
14491 swig_obj[0] = args;
14492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14493 if (!SWIG_IsOK(res1)) {
14494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14495 }
14496 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14497 {
14498 PyThreadState* __tstate = wxPyBeginAllowThreads();
14499 result = (int)(arg1)->GetNumberJoysticks();
14500 wxPyEndAllowThreads(__tstate);
14501 if (PyErr_Occurred()) SWIG_fail;
14502 }
14503 resultobj = SWIG_From_int(static_cast< int >(result));
14504 return resultobj;
14505 fail:
14506 return NULL;
14507 }
14508
14509
14510 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14511 PyObject *resultobj = 0;
14512 wxJoystick *arg1 = (wxJoystick *) 0 ;
14513 int result;
14514 void *argp1 = 0 ;
14515 int res1 = 0 ;
14516 PyObject *swig_obj[1] ;
14517
14518 if (!args) SWIG_fail;
14519 swig_obj[0] = args;
14520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14521 if (!SWIG_IsOK(res1)) {
14522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14523 }
14524 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14525 {
14526 PyThreadState* __tstate = wxPyBeginAllowThreads();
14527 result = (int)(arg1)->GetManufacturerId();
14528 wxPyEndAllowThreads(__tstate);
14529 if (PyErr_Occurred()) SWIG_fail;
14530 }
14531 resultobj = SWIG_From_int(static_cast< int >(result));
14532 return resultobj;
14533 fail:
14534 return NULL;
14535 }
14536
14537
14538 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14539 PyObject *resultobj = 0;
14540 wxJoystick *arg1 = (wxJoystick *) 0 ;
14541 int result;
14542 void *argp1 = 0 ;
14543 int res1 = 0 ;
14544 PyObject *swig_obj[1] ;
14545
14546 if (!args) SWIG_fail;
14547 swig_obj[0] = args;
14548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14549 if (!SWIG_IsOK(res1)) {
14550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14551 }
14552 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14553 {
14554 PyThreadState* __tstate = wxPyBeginAllowThreads();
14555 result = (int)(arg1)->GetProductId();
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 resultobj = SWIG_From_int(static_cast< int >(result));
14560 return resultobj;
14561 fail:
14562 return NULL;
14563 }
14564
14565
14566 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14567 PyObject *resultobj = 0;
14568 wxJoystick *arg1 = (wxJoystick *) 0 ;
14569 wxString result;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 PyObject *swig_obj[1] ;
14573
14574 if (!args) SWIG_fail;
14575 swig_obj[0] = args;
14576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14577 if (!SWIG_IsOK(res1)) {
14578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14579 }
14580 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14581 {
14582 PyThreadState* __tstate = wxPyBeginAllowThreads();
14583 result = (arg1)->GetProductName();
14584 wxPyEndAllowThreads(__tstate);
14585 if (PyErr_Occurred()) SWIG_fail;
14586 }
14587 {
14588 #if wxUSE_UNICODE
14589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14590 #else
14591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14592 #endif
14593 }
14594 return resultobj;
14595 fail:
14596 return NULL;
14597 }
14598
14599
14600 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14601 PyObject *resultobj = 0;
14602 wxJoystick *arg1 = (wxJoystick *) 0 ;
14603 int result;
14604 void *argp1 = 0 ;
14605 int res1 = 0 ;
14606 PyObject *swig_obj[1] ;
14607
14608 if (!args) SWIG_fail;
14609 swig_obj[0] = args;
14610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14611 if (!SWIG_IsOK(res1)) {
14612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14613 }
14614 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 result = (int)(arg1)->GetXMin();
14618 wxPyEndAllowThreads(__tstate);
14619 if (PyErr_Occurred()) SWIG_fail;
14620 }
14621 resultobj = SWIG_From_int(static_cast< int >(result));
14622 return resultobj;
14623 fail:
14624 return NULL;
14625 }
14626
14627
14628 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14629 PyObject *resultobj = 0;
14630 wxJoystick *arg1 = (wxJoystick *) 0 ;
14631 int result;
14632 void *argp1 = 0 ;
14633 int res1 = 0 ;
14634 PyObject *swig_obj[1] ;
14635
14636 if (!args) SWIG_fail;
14637 swig_obj[0] = args;
14638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14639 if (!SWIG_IsOK(res1)) {
14640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14641 }
14642 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14643 {
14644 PyThreadState* __tstate = wxPyBeginAllowThreads();
14645 result = (int)(arg1)->GetYMin();
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 resultobj = SWIG_From_int(static_cast< int >(result));
14650 return resultobj;
14651 fail:
14652 return NULL;
14653 }
14654
14655
14656 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14657 PyObject *resultobj = 0;
14658 wxJoystick *arg1 = (wxJoystick *) 0 ;
14659 int result;
14660 void *argp1 = 0 ;
14661 int res1 = 0 ;
14662 PyObject *swig_obj[1] ;
14663
14664 if (!args) SWIG_fail;
14665 swig_obj[0] = args;
14666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14667 if (!SWIG_IsOK(res1)) {
14668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14669 }
14670 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14671 {
14672 PyThreadState* __tstate = wxPyBeginAllowThreads();
14673 result = (int)(arg1)->GetZMin();
14674 wxPyEndAllowThreads(__tstate);
14675 if (PyErr_Occurred()) SWIG_fail;
14676 }
14677 resultobj = SWIG_From_int(static_cast< int >(result));
14678 return resultobj;
14679 fail:
14680 return NULL;
14681 }
14682
14683
14684 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14685 PyObject *resultobj = 0;
14686 wxJoystick *arg1 = (wxJoystick *) 0 ;
14687 int result;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 PyObject *swig_obj[1] ;
14691
14692 if (!args) SWIG_fail;
14693 swig_obj[0] = args;
14694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14695 if (!SWIG_IsOK(res1)) {
14696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14697 }
14698 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14699 {
14700 PyThreadState* __tstate = wxPyBeginAllowThreads();
14701 result = (int)(arg1)->GetXMax();
14702 wxPyEndAllowThreads(__tstate);
14703 if (PyErr_Occurred()) SWIG_fail;
14704 }
14705 resultobj = SWIG_From_int(static_cast< int >(result));
14706 return resultobj;
14707 fail:
14708 return NULL;
14709 }
14710
14711
14712 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14713 PyObject *resultobj = 0;
14714 wxJoystick *arg1 = (wxJoystick *) 0 ;
14715 int result;
14716 void *argp1 = 0 ;
14717 int res1 = 0 ;
14718 PyObject *swig_obj[1] ;
14719
14720 if (!args) SWIG_fail;
14721 swig_obj[0] = args;
14722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14723 if (!SWIG_IsOK(res1)) {
14724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14725 }
14726 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14727 {
14728 PyThreadState* __tstate = wxPyBeginAllowThreads();
14729 result = (int)(arg1)->GetYMax();
14730 wxPyEndAllowThreads(__tstate);
14731 if (PyErr_Occurred()) SWIG_fail;
14732 }
14733 resultobj = SWIG_From_int(static_cast< int >(result));
14734 return resultobj;
14735 fail:
14736 return NULL;
14737 }
14738
14739
14740 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14741 PyObject *resultobj = 0;
14742 wxJoystick *arg1 = (wxJoystick *) 0 ;
14743 int result;
14744 void *argp1 = 0 ;
14745 int res1 = 0 ;
14746 PyObject *swig_obj[1] ;
14747
14748 if (!args) SWIG_fail;
14749 swig_obj[0] = args;
14750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14751 if (!SWIG_IsOK(res1)) {
14752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14753 }
14754 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14755 {
14756 PyThreadState* __tstate = wxPyBeginAllowThreads();
14757 result = (int)(arg1)->GetZMax();
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 resultobj = SWIG_From_int(static_cast< int >(result));
14762 return resultobj;
14763 fail:
14764 return NULL;
14765 }
14766
14767
14768 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14769 PyObject *resultobj = 0;
14770 wxJoystick *arg1 = (wxJoystick *) 0 ;
14771 int result;
14772 void *argp1 = 0 ;
14773 int res1 = 0 ;
14774 PyObject *swig_obj[1] ;
14775
14776 if (!args) SWIG_fail;
14777 swig_obj[0] = args;
14778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14779 if (!SWIG_IsOK(res1)) {
14780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14781 }
14782 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 result = (int)(arg1)->GetNumberButtons();
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 resultobj = SWIG_From_int(static_cast< int >(result));
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14797 PyObject *resultobj = 0;
14798 wxJoystick *arg1 = (wxJoystick *) 0 ;
14799 int result;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 PyObject *swig_obj[1] ;
14803
14804 if (!args) SWIG_fail;
14805 swig_obj[0] = args;
14806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14807 if (!SWIG_IsOK(res1)) {
14808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14809 }
14810 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14811 {
14812 PyThreadState* __tstate = wxPyBeginAllowThreads();
14813 result = (int)(arg1)->GetNumberAxes();
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 resultobj = SWIG_From_int(static_cast< int >(result));
14818 return resultobj;
14819 fail:
14820 return NULL;
14821 }
14822
14823
14824 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14825 PyObject *resultobj = 0;
14826 wxJoystick *arg1 = (wxJoystick *) 0 ;
14827 int result;
14828 void *argp1 = 0 ;
14829 int res1 = 0 ;
14830 PyObject *swig_obj[1] ;
14831
14832 if (!args) SWIG_fail;
14833 swig_obj[0] = args;
14834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14837 }
14838 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14839 {
14840 PyThreadState* __tstate = wxPyBeginAllowThreads();
14841 result = (int)(arg1)->GetMaxButtons();
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 resultobj = SWIG_From_int(static_cast< int >(result));
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14853 PyObject *resultobj = 0;
14854 wxJoystick *arg1 = (wxJoystick *) 0 ;
14855 int result;
14856 void *argp1 = 0 ;
14857 int res1 = 0 ;
14858 PyObject *swig_obj[1] ;
14859
14860 if (!args) SWIG_fail;
14861 swig_obj[0] = args;
14862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14863 if (!SWIG_IsOK(res1)) {
14864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14865 }
14866 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 result = (int)(arg1)->GetMaxAxes();
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 resultobj = SWIG_From_int(static_cast< int >(result));
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14881 PyObject *resultobj = 0;
14882 wxJoystick *arg1 = (wxJoystick *) 0 ;
14883 int result;
14884 void *argp1 = 0 ;
14885 int res1 = 0 ;
14886 PyObject *swig_obj[1] ;
14887
14888 if (!args) SWIG_fail;
14889 swig_obj[0] = args;
14890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14891 if (!SWIG_IsOK(res1)) {
14892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14893 }
14894 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14895 {
14896 PyThreadState* __tstate = wxPyBeginAllowThreads();
14897 result = (int)(arg1)->GetPollingMin();
14898 wxPyEndAllowThreads(__tstate);
14899 if (PyErr_Occurred()) SWIG_fail;
14900 }
14901 resultobj = SWIG_From_int(static_cast< int >(result));
14902 return resultobj;
14903 fail:
14904 return NULL;
14905 }
14906
14907
14908 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14909 PyObject *resultobj = 0;
14910 wxJoystick *arg1 = (wxJoystick *) 0 ;
14911 int result;
14912 void *argp1 = 0 ;
14913 int res1 = 0 ;
14914 PyObject *swig_obj[1] ;
14915
14916 if (!args) SWIG_fail;
14917 swig_obj[0] = args;
14918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14919 if (!SWIG_IsOK(res1)) {
14920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14921 }
14922 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14923 {
14924 PyThreadState* __tstate = wxPyBeginAllowThreads();
14925 result = (int)(arg1)->GetPollingMax();
14926 wxPyEndAllowThreads(__tstate);
14927 if (PyErr_Occurred()) SWIG_fail;
14928 }
14929 resultobj = SWIG_From_int(static_cast< int >(result));
14930 return resultobj;
14931 fail:
14932 return NULL;
14933 }
14934
14935
14936 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14937 PyObject *resultobj = 0;
14938 wxJoystick *arg1 = (wxJoystick *) 0 ;
14939 int result;
14940 void *argp1 = 0 ;
14941 int res1 = 0 ;
14942 PyObject *swig_obj[1] ;
14943
14944 if (!args) SWIG_fail;
14945 swig_obj[0] = args;
14946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14947 if (!SWIG_IsOK(res1)) {
14948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14949 }
14950 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14951 {
14952 PyThreadState* __tstate = wxPyBeginAllowThreads();
14953 result = (int)(arg1)->GetRudderMin();
14954 wxPyEndAllowThreads(__tstate);
14955 if (PyErr_Occurred()) SWIG_fail;
14956 }
14957 resultobj = SWIG_From_int(static_cast< int >(result));
14958 return resultobj;
14959 fail:
14960 return NULL;
14961 }
14962
14963
14964 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14965 PyObject *resultobj = 0;
14966 wxJoystick *arg1 = (wxJoystick *) 0 ;
14967 int result;
14968 void *argp1 = 0 ;
14969 int res1 = 0 ;
14970 PyObject *swig_obj[1] ;
14971
14972 if (!args) SWIG_fail;
14973 swig_obj[0] = args;
14974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14975 if (!SWIG_IsOK(res1)) {
14976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14977 }
14978 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 result = (int)(arg1)->GetRudderMax();
14982 wxPyEndAllowThreads(__tstate);
14983 if (PyErr_Occurred()) SWIG_fail;
14984 }
14985 resultobj = SWIG_From_int(static_cast< int >(result));
14986 return resultobj;
14987 fail:
14988 return NULL;
14989 }
14990
14991
14992 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14993 PyObject *resultobj = 0;
14994 wxJoystick *arg1 = (wxJoystick *) 0 ;
14995 int result;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 PyObject *swig_obj[1] ;
14999
15000 if (!args) SWIG_fail;
15001 swig_obj[0] = args;
15002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15003 if (!SWIG_IsOK(res1)) {
15004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15005 }
15006 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 result = (int)(arg1)->GetUMin();
15010 wxPyEndAllowThreads(__tstate);
15011 if (PyErr_Occurred()) SWIG_fail;
15012 }
15013 resultobj = SWIG_From_int(static_cast< int >(result));
15014 return resultobj;
15015 fail:
15016 return NULL;
15017 }
15018
15019
15020 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15021 PyObject *resultobj = 0;
15022 wxJoystick *arg1 = (wxJoystick *) 0 ;
15023 int result;
15024 void *argp1 = 0 ;
15025 int res1 = 0 ;
15026 PyObject *swig_obj[1] ;
15027
15028 if (!args) SWIG_fail;
15029 swig_obj[0] = args;
15030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15031 if (!SWIG_IsOK(res1)) {
15032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15033 }
15034 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15035 {
15036 PyThreadState* __tstate = wxPyBeginAllowThreads();
15037 result = (int)(arg1)->GetUMax();
15038 wxPyEndAllowThreads(__tstate);
15039 if (PyErr_Occurred()) SWIG_fail;
15040 }
15041 resultobj = SWIG_From_int(static_cast< int >(result));
15042 return resultobj;
15043 fail:
15044 return NULL;
15045 }
15046
15047
15048 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15049 PyObject *resultobj = 0;
15050 wxJoystick *arg1 = (wxJoystick *) 0 ;
15051 int result;
15052 void *argp1 = 0 ;
15053 int res1 = 0 ;
15054 PyObject *swig_obj[1] ;
15055
15056 if (!args) SWIG_fail;
15057 swig_obj[0] = args;
15058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15059 if (!SWIG_IsOK(res1)) {
15060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15061 }
15062 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (int)(arg1)->GetVMin();
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 resultobj = SWIG_From_int(static_cast< int >(result));
15070 return resultobj;
15071 fail:
15072 return NULL;
15073 }
15074
15075
15076 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15077 PyObject *resultobj = 0;
15078 wxJoystick *arg1 = (wxJoystick *) 0 ;
15079 int result;
15080 void *argp1 = 0 ;
15081 int res1 = 0 ;
15082 PyObject *swig_obj[1] ;
15083
15084 if (!args) SWIG_fail;
15085 swig_obj[0] = args;
15086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15087 if (!SWIG_IsOK(res1)) {
15088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15089 }
15090 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15091 {
15092 PyThreadState* __tstate = wxPyBeginAllowThreads();
15093 result = (int)(arg1)->GetVMax();
15094 wxPyEndAllowThreads(__tstate);
15095 if (PyErr_Occurred()) SWIG_fail;
15096 }
15097 resultobj = SWIG_From_int(static_cast< int >(result));
15098 return resultobj;
15099 fail:
15100 return NULL;
15101 }
15102
15103
15104 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15105 PyObject *resultobj = 0;
15106 wxJoystick *arg1 = (wxJoystick *) 0 ;
15107 bool result;
15108 void *argp1 = 0 ;
15109 int res1 = 0 ;
15110 PyObject *swig_obj[1] ;
15111
15112 if (!args) SWIG_fail;
15113 swig_obj[0] = args;
15114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15115 if (!SWIG_IsOK(res1)) {
15116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
15117 }
15118 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 result = (bool)(arg1)->HasRudder();
15122 wxPyEndAllowThreads(__tstate);
15123 if (PyErr_Occurred()) SWIG_fail;
15124 }
15125 {
15126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15127 }
15128 return resultobj;
15129 fail:
15130 return NULL;
15131 }
15132
15133
15134 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15135 PyObject *resultobj = 0;
15136 wxJoystick *arg1 = (wxJoystick *) 0 ;
15137 bool result;
15138 void *argp1 = 0 ;
15139 int res1 = 0 ;
15140 PyObject *swig_obj[1] ;
15141
15142 if (!args) SWIG_fail;
15143 swig_obj[0] = args;
15144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15145 if (!SWIG_IsOK(res1)) {
15146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
15147 }
15148 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15149 {
15150 PyThreadState* __tstate = wxPyBeginAllowThreads();
15151 result = (bool)(arg1)->HasZ();
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 {
15156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15157 }
15158 return resultobj;
15159 fail:
15160 return NULL;
15161 }
15162
15163
15164 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15165 PyObject *resultobj = 0;
15166 wxJoystick *arg1 = (wxJoystick *) 0 ;
15167 bool result;
15168 void *argp1 = 0 ;
15169 int res1 = 0 ;
15170 PyObject *swig_obj[1] ;
15171
15172 if (!args) SWIG_fail;
15173 swig_obj[0] = args;
15174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15175 if (!SWIG_IsOK(res1)) {
15176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
15177 }
15178 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 result = (bool)(arg1)->HasU();
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15187 }
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195 PyObject *resultobj = 0;
15196 wxJoystick *arg1 = (wxJoystick *) 0 ;
15197 bool result;
15198 void *argp1 = 0 ;
15199 int res1 = 0 ;
15200 PyObject *swig_obj[1] ;
15201
15202 if (!args) SWIG_fail;
15203 swig_obj[0] = args;
15204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15205 if (!SWIG_IsOK(res1)) {
15206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15207 }
15208 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 result = (bool)(arg1)->HasV();
15212 wxPyEndAllowThreads(__tstate);
15213 if (PyErr_Occurred()) SWIG_fail;
15214 }
15215 {
15216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15217 }
15218 return resultobj;
15219 fail:
15220 return NULL;
15221 }
15222
15223
15224 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15225 PyObject *resultobj = 0;
15226 wxJoystick *arg1 = (wxJoystick *) 0 ;
15227 bool result;
15228 void *argp1 = 0 ;
15229 int res1 = 0 ;
15230 PyObject *swig_obj[1] ;
15231
15232 if (!args) SWIG_fail;
15233 swig_obj[0] = args;
15234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15235 if (!SWIG_IsOK(res1)) {
15236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15237 }
15238 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 result = (bool)(arg1)->HasPOV();
15242 wxPyEndAllowThreads(__tstate);
15243 if (PyErr_Occurred()) SWIG_fail;
15244 }
15245 {
15246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15247 }
15248 return resultobj;
15249 fail:
15250 return NULL;
15251 }
15252
15253
15254 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15255 PyObject *resultobj = 0;
15256 wxJoystick *arg1 = (wxJoystick *) 0 ;
15257 bool result;
15258 void *argp1 = 0 ;
15259 int res1 = 0 ;
15260 PyObject *swig_obj[1] ;
15261
15262 if (!args) SWIG_fail;
15263 swig_obj[0] = args;
15264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15265 if (!SWIG_IsOK(res1)) {
15266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15267 }
15268 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15269 {
15270 PyThreadState* __tstate = wxPyBeginAllowThreads();
15271 result = (bool)(arg1)->HasPOV4Dir();
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 {
15276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15277 }
15278 return resultobj;
15279 fail:
15280 return NULL;
15281 }
15282
15283
15284 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15285 PyObject *resultobj = 0;
15286 wxJoystick *arg1 = (wxJoystick *) 0 ;
15287 bool result;
15288 void *argp1 = 0 ;
15289 int res1 = 0 ;
15290 PyObject *swig_obj[1] ;
15291
15292 if (!args) SWIG_fail;
15293 swig_obj[0] = args;
15294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15295 if (!SWIG_IsOK(res1)) {
15296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15297 }
15298 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = (bool)(arg1)->HasPOVCTS();
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 {
15306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15307 }
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15315 PyObject *resultobj = 0;
15316 wxJoystick *arg1 = (wxJoystick *) 0 ;
15317 wxWindow *arg2 = (wxWindow *) 0 ;
15318 int arg3 = (int) 0 ;
15319 bool result;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 void *argp2 = 0 ;
15323 int res2 = 0 ;
15324 int val3 ;
15325 int ecode3 = 0 ;
15326 PyObject * obj0 = 0 ;
15327 PyObject * obj1 = 0 ;
15328 PyObject * obj2 = 0 ;
15329 char * kwnames[] = {
15330 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15331 };
15332
15333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15335 if (!SWIG_IsOK(res1)) {
15336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15337 }
15338 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15340 if (!SWIG_IsOK(res2)) {
15341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15342 }
15343 arg2 = reinterpret_cast< wxWindow * >(argp2);
15344 if (obj2) {
15345 ecode3 = SWIG_AsVal_int(obj2, &val3);
15346 if (!SWIG_IsOK(ecode3)) {
15347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15348 }
15349 arg3 = static_cast< int >(val3);
15350 }
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = (bool)(arg1)->SetCapture(arg2,arg3);
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 {
15358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15359 }
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15367 PyObject *resultobj = 0;
15368 wxJoystick *arg1 = (wxJoystick *) 0 ;
15369 bool result;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 PyObject *swig_obj[1] ;
15373
15374 if (!args) SWIG_fail;
15375 swig_obj[0] = args;
15376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15377 if (!SWIG_IsOK(res1)) {
15378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15379 }
15380 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15381 {
15382 PyThreadState* __tstate = wxPyBeginAllowThreads();
15383 result = (bool)(arg1)->ReleaseCapture();
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 {
15388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15389 }
15390 return resultobj;
15391 fail:
15392 return NULL;
15393 }
15394
15395
15396 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15397 PyObject *obj;
15398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15399 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15400 return SWIG_Py_Void();
15401 }
15402
15403 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15404 return SWIG_Python_InitShadowInstance(args);
15405 }
15406
15407 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15408 PyObject *resultobj = 0;
15409 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15410 int arg2 = (int) 0 ;
15411 int arg3 = (int) wxJOYSTICK1 ;
15412 int arg4 = (int) 0 ;
15413 wxJoystickEvent *result = 0 ;
15414 int val1 ;
15415 int ecode1 = 0 ;
15416 int val2 ;
15417 int ecode2 = 0 ;
15418 int val3 ;
15419 int ecode3 = 0 ;
15420 int val4 ;
15421 int ecode4 = 0 ;
15422 PyObject * obj0 = 0 ;
15423 PyObject * obj1 = 0 ;
15424 PyObject * obj2 = 0 ;
15425 PyObject * obj3 = 0 ;
15426 char * kwnames[] = {
15427 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15428 };
15429
15430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15431 if (obj0) {
15432 ecode1 = SWIG_AsVal_int(obj0, &val1);
15433 if (!SWIG_IsOK(ecode1)) {
15434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15435 }
15436 arg1 = static_cast< wxEventType >(val1);
15437 }
15438 if (obj1) {
15439 ecode2 = SWIG_AsVal_int(obj1, &val2);
15440 if (!SWIG_IsOK(ecode2)) {
15441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15442 }
15443 arg2 = static_cast< int >(val2);
15444 }
15445 if (obj2) {
15446 ecode3 = SWIG_AsVal_int(obj2, &val3);
15447 if (!SWIG_IsOK(ecode3)) {
15448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15449 }
15450 arg3 = static_cast< int >(val3);
15451 }
15452 if (obj3) {
15453 ecode4 = SWIG_AsVal_int(obj3, &val4);
15454 if (!SWIG_IsOK(ecode4)) {
15455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15456 }
15457 arg4 = static_cast< int >(val4);
15458 }
15459 {
15460 PyThreadState* __tstate = wxPyBeginAllowThreads();
15461 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15473 PyObject *resultobj = 0;
15474 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15475 wxPoint result;
15476 void *argp1 = 0 ;
15477 int res1 = 0 ;
15478 PyObject *swig_obj[1] ;
15479
15480 if (!args) SWIG_fail;
15481 swig_obj[0] = args;
15482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15483 if (!SWIG_IsOK(res1)) {
15484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15485 }
15486 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15487 {
15488 PyThreadState* __tstate = wxPyBeginAllowThreads();
15489 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15490 wxPyEndAllowThreads(__tstate);
15491 if (PyErr_Occurred()) SWIG_fail;
15492 }
15493 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15501 PyObject *resultobj = 0;
15502 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15503 int result;
15504 void *argp1 = 0 ;
15505 int res1 = 0 ;
15506 PyObject *swig_obj[1] ;
15507
15508 if (!args) SWIG_fail;
15509 swig_obj[0] = args;
15510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15511 if (!SWIG_IsOK(res1)) {
15512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15513 }
15514 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15518 wxPyEndAllowThreads(__tstate);
15519 if (PyErr_Occurred()) SWIG_fail;
15520 }
15521 resultobj = SWIG_From_int(static_cast< int >(result));
15522 return resultobj;
15523 fail:
15524 return NULL;
15525 }
15526
15527
15528 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15529 PyObject *resultobj = 0;
15530 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15531 int result;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 PyObject *swig_obj[1] ;
15535
15536 if (!args) SWIG_fail;
15537 swig_obj[0] = args;
15538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15539 if (!SWIG_IsOK(res1)) {
15540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15541 }
15542 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15546 wxPyEndAllowThreads(__tstate);
15547 if (PyErr_Occurred()) SWIG_fail;
15548 }
15549 resultobj = SWIG_From_int(static_cast< int >(result));
15550 return resultobj;
15551 fail:
15552 return NULL;
15553 }
15554
15555
15556 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15557 PyObject *resultobj = 0;
15558 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15559 int result;
15560 void *argp1 = 0 ;
15561 int res1 = 0 ;
15562 PyObject *swig_obj[1] ;
15563
15564 if (!args) SWIG_fail;
15565 swig_obj[0] = args;
15566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15569 }
15570 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15571 {
15572 PyThreadState* __tstate = wxPyBeginAllowThreads();
15573 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 resultobj = SWIG_From_int(static_cast< int >(result));
15578 return resultobj;
15579 fail:
15580 return NULL;
15581 }
15582
15583
15584 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15585 PyObject *resultobj = 0;
15586 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15587 int result;
15588 void *argp1 = 0 ;
15589 int res1 = 0 ;
15590 PyObject *swig_obj[1] ;
15591
15592 if (!args) SWIG_fail;
15593 swig_obj[0] = args;
15594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15595 if (!SWIG_IsOK(res1)) {
15596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15597 }
15598 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15599 {
15600 PyThreadState* __tstate = wxPyBeginAllowThreads();
15601 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15602 wxPyEndAllowThreads(__tstate);
15603 if (PyErr_Occurred()) SWIG_fail;
15604 }
15605 resultobj = SWIG_From_int(static_cast< int >(result));
15606 return resultobj;
15607 fail:
15608 return NULL;
15609 }
15610
15611
15612 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15613 PyObject *resultobj = 0;
15614 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15615 int arg2 ;
15616 void *argp1 = 0 ;
15617 int res1 = 0 ;
15618 int val2 ;
15619 int ecode2 = 0 ;
15620 PyObject * obj0 = 0 ;
15621 PyObject * obj1 = 0 ;
15622 char * kwnames[] = {
15623 (char *) "self",(char *) "stick", NULL
15624 };
15625
15626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15628 if (!SWIG_IsOK(res1)) {
15629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15630 }
15631 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15632 ecode2 = SWIG_AsVal_int(obj1, &val2);
15633 if (!SWIG_IsOK(ecode2)) {
15634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15635 }
15636 arg2 = static_cast< int >(val2);
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 (arg1)->SetJoystick(arg2);
15640 wxPyEndAllowThreads(__tstate);
15641 if (PyErr_Occurred()) SWIG_fail;
15642 }
15643 resultobj = SWIG_Py_Void();
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15651 PyObject *resultobj = 0;
15652 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15653 int arg2 ;
15654 void *argp1 = 0 ;
15655 int res1 = 0 ;
15656 int val2 ;
15657 int ecode2 = 0 ;
15658 PyObject * obj0 = 0 ;
15659 PyObject * obj1 = 0 ;
15660 char * kwnames[] = {
15661 (char *) "self",(char *) "state", NULL
15662 };
15663
15664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15666 if (!SWIG_IsOK(res1)) {
15667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15668 }
15669 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15670 ecode2 = SWIG_AsVal_int(obj1, &val2);
15671 if (!SWIG_IsOK(ecode2)) {
15672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15673 }
15674 arg2 = static_cast< int >(val2);
15675 {
15676 PyThreadState* __tstate = wxPyBeginAllowThreads();
15677 (arg1)->SetButtonState(arg2);
15678 wxPyEndAllowThreads(__tstate);
15679 if (PyErr_Occurred()) SWIG_fail;
15680 }
15681 resultobj = SWIG_Py_Void();
15682 return resultobj;
15683 fail:
15684 return NULL;
15685 }
15686
15687
15688 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15689 PyObject *resultobj = 0;
15690 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15691 int arg2 ;
15692 void *argp1 = 0 ;
15693 int res1 = 0 ;
15694 int val2 ;
15695 int ecode2 = 0 ;
15696 PyObject * obj0 = 0 ;
15697 PyObject * obj1 = 0 ;
15698 char * kwnames[] = {
15699 (char *) "self",(char *) "change", NULL
15700 };
15701
15702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15704 if (!SWIG_IsOK(res1)) {
15705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15706 }
15707 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15708 ecode2 = SWIG_AsVal_int(obj1, &val2);
15709 if (!SWIG_IsOK(ecode2)) {
15710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15711 }
15712 arg2 = static_cast< int >(val2);
15713 {
15714 PyThreadState* __tstate = wxPyBeginAllowThreads();
15715 (arg1)->SetButtonChange(arg2);
15716 wxPyEndAllowThreads(__tstate);
15717 if (PyErr_Occurred()) SWIG_fail;
15718 }
15719 resultobj = SWIG_Py_Void();
15720 return resultobj;
15721 fail:
15722 return NULL;
15723 }
15724
15725
15726 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15727 PyObject *resultobj = 0;
15728 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15729 wxPoint *arg2 = 0 ;
15730 void *argp1 = 0 ;
15731 int res1 = 0 ;
15732 wxPoint temp2 ;
15733 PyObject * obj0 = 0 ;
15734 PyObject * obj1 = 0 ;
15735 char * kwnames[] = {
15736 (char *) "self",(char *) "pos", NULL
15737 };
15738
15739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15741 if (!SWIG_IsOK(res1)) {
15742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15743 }
15744 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15745 {
15746 arg2 = &temp2;
15747 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15748 }
15749 {
15750 PyThreadState* __tstate = wxPyBeginAllowThreads();
15751 (arg1)->SetPosition((wxPoint const &)*arg2);
15752 wxPyEndAllowThreads(__tstate);
15753 if (PyErr_Occurred()) SWIG_fail;
15754 }
15755 resultobj = SWIG_Py_Void();
15756 return resultobj;
15757 fail:
15758 return NULL;
15759 }
15760
15761
15762 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15763 PyObject *resultobj = 0;
15764 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15765 int arg2 ;
15766 void *argp1 = 0 ;
15767 int res1 = 0 ;
15768 int val2 ;
15769 int ecode2 = 0 ;
15770 PyObject * obj0 = 0 ;
15771 PyObject * obj1 = 0 ;
15772 char * kwnames[] = {
15773 (char *) "self",(char *) "zPos", NULL
15774 };
15775
15776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15778 if (!SWIG_IsOK(res1)) {
15779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15780 }
15781 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15782 ecode2 = SWIG_AsVal_int(obj1, &val2);
15783 if (!SWIG_IsOK(ecode2)) {
15784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15785 }
15786 arg2 = static_cast< int >(val2);
15787 {
15788 PyThreadState* __tstate = wxPyBeginAllowThreads();
15789 (arg1)->SetZPosition(arg2);
15790 wxPyEndAllowThreads(__tstate);
15791 if (PyErr_Occurred()) SWIG_fail;
15792 }
15793 resultobj = SWIG_Py_Void();
15794 return resultobj;
15795 fail:
15796 return NULL;
15797 }
15798
15799
15800 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15801 PyObject *resultobj = 0;
15802 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15803 bool result;
15804 void *argp1 = 0 ;
15805 int res1 = 0 ;
15806 PyObject *swig_obj[1] ;
15807
15808 if (!args) SWIG_fail;
15809 swig_obj[0] = args;
15810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15811 if (!SWIG_IsOK(res1)) {
15812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15813 }
15814 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15815 {
15816 PyThreadState* __tstate = wxPyBeginAllowThreads();
15817 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15818 wxPyEndAllowThreads(__tstate);
15819 if (PyErr_Occurred()) SWIG_fail;
15820 }
15821 {
15822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15823 }
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15831 PyObject *resultobj = 0;
15832 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15833 bool result;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 PyObject *swig_obj[1] ;
15837
15838 if (!args) SWIG_fail;
15839 swig_obj[0] = args;
15840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15841 if (!SWIG_IsOK(res1)) {
15842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15843 }
15844 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15845 {
15846 PyThreadState* __tstate = wxPyBeginAllowThreads();
15847 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15848 wxPyEndAllowThreads(__tstate);
15849 if (PyErr_Occurred()) SWIG_fail;
15850 }
15851 {
15852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15853 }
15854 return resultobj;
15855 fail:
15856 return NULL;
15857 }
15858
15859
15860 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15861 PyObject *resultobj = 0;
15862 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15863 bool result;
15864 void *argp1 = 0 ;
15865 int res1 = 0 ;
15866 PyObject *swig_obj[1] ;
15867
15868 if (!args) SWIG_fail;
15869 swig_obj[0] = args;
15870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15871 if (!SWIG_IsOK(res1)) {
15872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15873 }
15874 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15878 wxPyEndAllowThreads(__tstate);
15879 if (PyErr_Occurred()) SWIG_fail;
15880 }
15881 {
15882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15883 }
15884 return resultobj;
15885 fail:
15886 return NULL;
15887 }
15888
15889
15890 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15891 PyObject *resultobj = 0;
15892 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15893 int arg2 = (int) wxJOY_BUTTON_ANY ;
15894 bool result;
15895 void *argp1 = 0 ;
15896 int res1 = 0 ;
15897 int val2 ;
15898 int ecode2 = 0 ;
15899 PyObject * obj0 = 0 ;
15900 PyObject * obj1 = 0 ;
15901 char * kwnames[] = {
15902 (char *) "self",(char *) "but", NULL
15903 };
15904
15905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15907 if (!SWIG_IsOK(res1)) {
15908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15909 }
15910 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15911 if (obj1) {
15912 ecode2 = SWIG_AsVal_int(obj1, &val2);
15913 if (!SWIG_IsOK(ecode2)) {
15914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15915 }
15916 arg2 = static_cast< int >(val2);
15917 }
15918 {
15919 PyThreadState* __tstate = wxPyBeginAllowThreads();
15920 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15921 wxPyEndAllowThreads(__tstate);
15922 if (PyErr_Occurred()) SWIG_fail;
15923 }
15924 {
15925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15926 }
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15934 PyObject *resultobj = 0;
15935 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15936 int arg2 = (int) wxJOY_BUTTON_ANY ;
15937 bool result;
15938 void *argp1 = 0 ;
15939 int res1 = 0 ;
15940 int val2 ;
15941 int ecode2 = 0 ;
15942 PyObject * obj0 = 0 ;
15943 PyObject * obj1 = 0 ;
15944 char * kwnames[] = {
15945 (char *) "self",(char *) "but", NULL
15946 };
15947
15948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15950 if (!SWIG_IsOK(res1)) {
15951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15952 }
15953 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15954 if (obj1) {
15955 ecode2 = SWIG_AsVal_int(obj1, &val2);
15956 if (!SWIG_IsOK(ecode2)) {
15957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15958 }
15959 arg2 = static_cast< int >(val2);
15960 }
15961 {
15962 PyThreadState* __tstate = wxPyBeginAllowThreads();
15963 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15964 wxPyEndAllowThreads(__tstate);
15965 if (PyErr_Occurred()) SWIG_fail;
15966 }
15967 {
15968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15969 }
15970 return resultobj;
15971 fail:
15972 return NULL;
15973 }
15974
15975
15976 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15977 PyObject *resultobj = 0;
15978 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15979 int arg2 = (int) wxJOY_BUTTON_ANY ;
15980 bool result;
15981 void *argp1 = 0 ;
15982 int res1 = 0 ;
15983 int val2 ;
15984 int ecode2 = 0 ;
15985 PyObject * obj0 = 0 ;
15986 PyObject * obj1 = 0 ;
15987 char * kwnames[] = {
15988 (char *) "self",(char *) "but", NULL
15989 };
15990
15991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15993 if (!SWIG_IsOK(res1)) {
15994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15995 }
15996 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15997 if (obj1) {
15998 ecode2 = SWIG_AsVal_int(obj1, &val2);
15999 if (!SWIG_IsOK(ecode2)) {
16000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
16001 }
16002 arg2 = static_cast< int >(val2);
16003 }
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 {
16011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16012 }
16013 return resultobj;
16014 fail:
16015 return NULL;
16016 }
16017
16018
16019 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16020 PyObject *obj;
16021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16022 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16023 return SWIG_Py_Void();
16024 }
16025
16026 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16027 return SWIG_Python_InitShadowInstance(args);
16028 }
16029
16030 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16031 PyObject *resultobj = 0;
16032 wxString const &arg1_defvalue = wxPyEmptyString ;
16033 wxString *arg1 = (wxString *) &arg1_defvalue ;
16034 wxSound *result = 0 ;
16035 bool temp1 = false ;
16036 PyObject * obj0 = 0 ;
16037 char * kwnames[] = {
16038 (char *) "fileName", NULL
16039 };
16040
16041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16042 if (obj0) {
16043 {
16044 arg1 = wxString_in_helper(obj0);
16045 if (arg1 == NULL) SWIG_fail;
16046 temp1 = true;
16047 }
16048 }
16049 {
16050 if (!wxPyCheckForApp()) SWIG_fail;
16051 PyThreadState* __tstate = wxPyBeginAllowThreads();
16052 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16053 wxPyEndAllowThreads(__tstate);
16054 if (PyErr_Occurred()) SWIG_fail;
16055 }
16056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16057 {
16058 if (temp1)
16059 delete arg1;
16060 }
16061 return resultobj;
16062 fail:
16063 {
16064 if (temp1)
16065 delete arg1;
16066 }
16067 return NULL;
16068 }
16069
16070
16071 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16072 PyObject *resultobj = 0;
16073 PyObject *arg1 = (PyObject *) 0 ;
16074 wxSound *result = 0 ;
16075 PyObject * obj0 = 0 ;
16076 char * kwnames[] = {
16077 (char *) "data", NULL
16078 };
16079
16080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16081 arg1 = obj0;
16082 {
16083 if (!wxPyCheckForApp()) SWIG_fail;
16084 PyThreadState* __tstate = wxPyBeginAllowThreads();
16085 result = (wxSound *)new_wxSound(arg1);
16086 wxPyEndAllowThreads(__tstate);
16087 if (PyErr_Occurred()) SWIG_fail;
16088 }
16089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16090 return resultobj;
16091 fail:
16092 return NULL;
16093 }
16094
16095
16096 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16097 PyObject *resultobj = 0;
16098 wxSound *arg1 = (wxSound *) 0 ;
16099 void *argp1 = 0 ;
16100 int res1 = 0 ;
16101 PyObject *swig_obj[1] ;
16102
16103 if (!args) SWIG_fail;
16104 swig_obj[0] = args;
16105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16106 if (!SWIG_IsOK(res1)) {
16107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16108 }
16109 arg1 = reinterpret_cast< wxSound * >(argp1);
16110 {
16111 PyThreadState* __tstate = wxPyBeginAllowThreads();
16112 delete arg1;
16113
16114 wxPyEndAllowThreads(__tstate);
16115 if (PyErr_Occurred()) SWIG_fail;
16116 }
16117 resultobj = SWIG_Py_Void();
16118 return resultobj;
16119 fail:
16120 return NULL;
16121 }
16122
16123
16124 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16125 PyObject *resultobj = 0;
16126 wxSound *arg1 = (wxSound *) 0 ;
16127 wxString *arg2 = 0 ;
16128 bool result;
16129 void *argp1 = 0 ;
16130 int res1 = 0 ;
16131 bool temp2 = false ;
16132 PyObject * obj0 = 0 ;
16133 PyObject * obj1 = 0 ;
16134 char * kwnames[] = {
16135 (char *) "self",(char *) "fileName", NULL
16136 };
16137
16138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
16139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16140 if (!SWIG_IsOK(res1)) {
16141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
16142 }
16143 arg1 = reinterpret_cast< wxSound * >(argp1);
16144 {
16145 arg2 = wxString_in_helper(obj1);
16146 if (arg2 == NULL) SWIG_fail;
16147 temp2 = true;
16148 }
16149 {
16150 PyThreadState* __tstate = wxPyBeginAllowThreads();
16151 result = (bool)(arg1)->Create((wxString const &)*arg2);
16152 wxPyEndAllowThreads(__tstate);
16153 if (PyErr_Occurred()) SWIG_fail;
16154 }
16155 {
16156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16157 }
16158 {
16159 if (temp2)
16160 delete arg2;
16161 }
16162 return resultobj;
16163 fail:
16164 {
16165 if (temp2)
16166 delete arg2;
16167 }
16168 return NULL;
16169 }
16170
16171
16172 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16173 PyObject *resultobj = 0;
16174 wxSound *arg1 = (wxSound *) 0 ;
16175 PyObject *arg2 = (PyObject *) 0 ;
16176 bool result;
16177 void *argp1 = 0 ;
16178 int res1 = 0 ;
16179 PyObject * obj0 = 0 ;
16180 PyObject * obj1 = 0 ;
16181 char * kwnames[] = {
16182 (char *) "self",(char *) "data", NULL
16183 };
16184
16185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16187 if (!SWIG_IsOK(res1)) {
16188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16189 }
16190 arg1 = reinterpret_cast< wxSound * >(argp1);
16191 arg2 = obj1;
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = (bool)wxSound_CreateFromData(arg1,arg2);
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 {
16199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16200 }
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16208 PyObject *resultobj = 0;
16209 wxSound *arg1 = (wxSound *) 0 ;
16210 bool result;
16211 void *argp1 = 0 ;
16212 int res1 = 0 ;
16213 PyObject *swig_obj[1] ;
16214
16215 if (!args) SWIG_fail;
16216 swig_obj[0] = args;
16217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16218 if (!SWIG_IsOK(res1)) {
16219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16220 }
16221 arg1 = reinterpret_cast< wxSound * >(argp1);
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 result = (bool)(arg1)->IsOk();
16225 wxPyEndAllowThreads(__tstate);
16226 if (PyErr_Occurred()) SWIG_fail;
16227 }
16228 {
16229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16230 }
16231 return resultobj;
16232 fail:
16233 return NULL;
16234 }
16235
16236
16237 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16238 PyObject *resultobj = 0;
16239 wxSound *arg1 = (wxSound *) 0 ;
16240 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16241 bool result;
16242 void *argp1 = 0 ;
16243 int res1 = 0 ;
16244 unsigned int val2 ;
16245 int ecode2 = 0 ;
16246 PyObject * obj0 = 0 ;
16247 PyObject * obj1 = 0 ;
16248 char * kwnames[] = {
16249 (char *) "self",(char *) "flags", NULL
16250 };
16251
16252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16254 if (!SWIG_IsOK(res1)) {
16255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16256 }
16257 arg1 = reinterpret_cast< wxSound * >(argp1);
16258 if (obj1) {
16259 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16260 if (!SWIG_IsOK(ecode2)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16262 }
16263 arg2 = static_cast< unsigned int >(val2);
16264 }
16265 {
16266 if (!wxPyCheckForApp()) SWIG_fail;
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 result = (bool)((wxSound const *)arg1)->Play(arg2);
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16274 }
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16282 PyObject *resultobj = 0;
16283 wxString *arg1 = 0 ;
16284 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16285 bool result;
16286 bool temp1 = false ;
16287 unsigned int val2 ;
16288 int ecode2 = 0 ;
16289 PyObject * obj0 = 0 ;
16290 PyObject * obj1 = 0 ;
16291 char * kwnames[] = {
16292 (char *) "filename",(char *) "flags", NULL
16293 };
16294
16295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16296 {
16297 arg1 = wxString_in_helper(obj0);
16298 if (arg1 == NULL) SWIG_fail;
16299 temp1 = true;
16300 }
16301 if (obj1) {
16302 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16303 if (!SWIG_IsOK(ecode2)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16305 }
16306 arg2 = static_cast< unsigned int >(val2);
16307 }
16308 {
16309 if (!wxPyCheckForApp()) SWIG_fail;
16310 PyThreadState* __tstate = wxPyBeginAllowThreads();
16311 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16312 wxPyEndAllowThreads(__tstate);
16313 if (PyErr_Occurred()) SWIG_fail;
16314 }
16315 {
16316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16317 }
16318 {
16319 if (temp1)
16320 delete arg1;
16321 }
16322 return resultobj;
16323 fail:
16324 {
16325 if (temp1)
16326 delete arg1;
16327 }
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16333 PyObject *resultobj = 0;
16334
16335 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16336 {
16337 if (!wxPyCheckForApp()) SWIG_fail;
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 wxSound::Stop();
16340 wxPyEndAllowThreads(__tstate);
16341 if (PyErr_Occurred()) SWIG_fail;
16342 }
16343 resultobj = SWIG_Py_Void();
16344 return resultobj;
16345 fail:
16346 return NULL;
16347 }
16348
16349
16350 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16351 PyObject *obj;
16352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16353 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16354 return SWIG_Py_Void();
16355 }
16356
16357 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16358 return SWIG_Python_InitShadowInstance(args);
16359 }
16360
16361 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16362 PyObject *resultobj = 0;
16363 wxString *arg1 = 0 ;
16364 wxString *arg2 = 0 ;
16365 wxString *arg3 = 0 ;
16366 wxString *arg4 = 0 ;
16367 wxFileTypeInfo *result = 0 ;
16368 bool temp1 = false ;
16369 bool temp2 = false ;
16370 bool temp3 = false ;
16371 bool temp4 = false ;
16372 PyObject * obj0 = 0 ;
16373 PyObject * obj1 = 0 ;
16374 PyObject * obj2 = 0 ;
16375 PyObject * obj3 = 0 ;
16376 char * kwnames[] = {
16377 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16378 };
16379
16380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16381 {
16382 arg1 = wxString_in_helper(obj0);
16383 if (arg1 == NULL) SWIG_fail;
16384 temp1 = true;
16385 }
16386 {
16387 arg2 = wxString_in_helper(obj1);
16388 if (arg2 == NULL) SWIG_fail;
16389 temp2 = true;
16390 }
16391 {
16392 arg3 = wxString_in_helper(obj2);
16393 if (arg3 == NULL) SWIG_fail;
16394 temp3 = true;
16395 }
16396 {
16397 arg4 = wxString_in_helper(obj3);
16398 if (arg4 == NULL) SWIG_fail;
16399 temp4 = true;
16400 }
16401 {
16402 PyThreadState* __tstate = wxPyBeginAllowThreads();
16403 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16404 wxPyEndAllowThreads(__tstate);
16405 if (PyErr_Occurred()) SWIG_fail;
16406 }
16407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16408 {
16409 if (temp1)
16410 delete arg1;
16411 }
16412 {
16413 if (temp2)
16414 delete arg2;
16415 }
16416 {
16417 if (temp3)
16418 delete arg3;
16419 }
16420 {
16421 if (temp4)
16422 delete arg4;
16423 }
16424 return resultobj;
16425 fail:
16426 {
16427 if (temp1)
16428 delete arg1;
16429 }
16430 {
16431 if (temp2)
16432 delete arg2;
16433 }
16434 {
16435 if (temp3)
16436 delete arg3;
16437 }
16438 {
16439 if (temp4)
16440 delete arg4;
16441 }
16442 return NULL;
16443 }
16444
16445
16446 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj = 0;
16448 wxArrayString *arg1 = 0 ;
16449 wxFileTypeInfo *result = 0 ;
16450 bool temp1 = false ;
16451 PyObject * obj0 = 0 ;
16452 char * kwnames[] = {
16453 (char *) "sArray", NULL
16454 };
16455
16456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16457 {
16458 if (! PySequence_Check(obj0)) {
16459 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16460 SWIG_fail;
16461 }
16462 arg1 = new wxArrayString;
16463 temp1 = true;
16464 int i, len=PySequence_Length(obj0);
16465 for (i=0; i<len; i++) {
16466 PyObject* item = PySequence_GetItem(obj0, i);
16467 wxString* s = wxString_in_helper(item);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 arg1->Add(*s);
16470 delete s;
16471 Py_DECREF(item);
16472 }
16473 }
16474 {
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16477 wxPyEndAllowThreads(__tstate);
16478 if (PyErr_Occurred()) SWIG_fail;
16479 }
16480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16481 {
16482 if (temp1) delete arg1;
16483 }
16484 return resultobj;
16485 fail:
16486 {
16487 if (temp1) delete arg1;
16488 }
16489 return NULL;
16490 }
16491
16492
16493 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16494 PyObject *resultobj = 0;
16495 wxFileTypeInfo *result = 0 ;
16496
16497 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16512 PyObject *resultobj = 0;
16513 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16514 bool result;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 PyObject *swig_obj[1] ;
16518
16519 if (!args) SWIG_fail;
16520 swig_obj[0] = args;
16521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16522 if (!SWIG_IsOK(res1)) {
16523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16524 }
16525 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16526 {
16527 PyThreadState* __tstate = wxPyBeginAllowThreads();
16528 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16529 wxPyEndAllowThreads(__tstate);
16530 if (PyErr_Occurred()) SWIG_fail;
16531 }
16532 {
16533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16534 }
16535 return resultobj;
16536 fail:
16537 return NULL;
16538 }
16539
16540
16541 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj = 0;
16543 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16544 wxString *arg2 = 0 ;
16545 int arg3 = (int) 0 ;
16546 void *argp1 = 0 ;
16547 int res1 = 0 ;
16548 bool temp2 = false ;
16549 int val3 ;
16550 int ecode3 = 0 ;
16551 PyObject * obj0 = 0 ;
16552 PyObject * obj1 = 0 ;
16553 PyObject * obj2 = 0 ;
16554 char * kwnames[] = {
16555 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16556 };
16557
16558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16560 if (!SWIG_IsOK(res1)) {
16561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16562 }
16563 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16564 {
16565 arg2 = wxString_in_helper(obj1);
16566 if (arg2 == NULL) SWIG_fail;
16567 temp2 = true;
16568 }
16569 if (obj2) {
16570 ecode3 = SWIG_AsVal_int(obj2, &val3);
16571 if (!SWIG_IsOK(ecode3)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16573 }
16574 arg3 = static_cast< int >(val3);
16575 }
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 resultobj = SWIG_Py_Void();
16583 {
16584 if (temp2)
16585 delete arg2;
16586 }
16587 return resultobj;
16588 fail:
16589 {
16590 if (temp2)
16591 delete arg2;
16592 }
16593 return NULL;
16594 }
16595
16596
16597 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16598 PyObject *resultobj = 0;
16599 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16600 wxString *arg2 = 0 ;
16601 void *argp1 = 0 ;
16602 int res1 = 0 ;
16603 bool temp2 = false ;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 char * kwnames[] = {
16607 (char *) "self",(char *) "shortDesc", NULL
16608 };
16609
16610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16612 if (!SWIG_IsOK(res1)) {
16613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16614 }
16615 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16616 {
16617 arg2 = wxString_in_helper(obj1);
16618 if (arg2 == NULL) SWIG_fail;
16619 temp2 = true;
16620 }
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 (arg1)->SetShortDesc((wxString const &)*arg2);
16624 wxPyEndAllowThreads(__tstate);
16625 if (PyErr_Occurred()) SWIG_fail;
16626 }
16627 resultobj = SWIG_Py_Void();
16628 {
16629 if (temp2)
16630 delete arg2;
16631 }
16632 return resultobj;
16633 fail:
16634 {
16635 if (temp2)
16636 delete arg2;
16637 }
16638 return NULL;
16639 }
16640
16641
16642 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16643 PyObject *resultobj = 0;
16644 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16645 wxString *result = 0 ;
16646 void *argp1 = 0 ;
16647 int res1 = 0 ;
16648 PyObject *swig_obj[1] ;
16649
16650 if (!args) SWIG_fail;
16651 swig_obj[0] = args;
16652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16653 if (!SWIG_IsOK(res1)) {
16654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16655 }
16656 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16657 {
16658 PyThreadState* __tstate = wxPyBeginAllowThreads();
16659 {
16660 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16661 result = (wxString *) &_result_ref;
16662 }
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 {
16667 #if wxUSE_UNICODE
16668 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16669 #else
16670 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16671 #endif
16672 }
16673 return resultobj;
16674 fail:
16675 return NULL;
16676 }
16677
16678
16679 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16680 PyObject *resultobj = 0;
16681 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16682 wxString *result = 0 ;
16683 void *argp1 = 0 ;
16684 int res1 = 0 ;
16685 PyObject *swig_obj[1] ;
16686
16687 if (!args) SWIG_fail;
16688 swig_obj[0] = args;
16689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16690 if (!SWIG_IsOK(res1)) {
16691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16692 }
16693 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16694 {
16695 PyThreadState* __tstate = wxPyBeginAllowThreads();
16696 {
16697 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16698 result = (wxString *) &_result_ref;
16699 }
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 {
16704 #if wxUSE_UNICODE
16705 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16706 #else
16707 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16708 #endif
16709 }
16710 return resultobj;
16711 fail:
16712 return NULL;
16713 }
16714
16715
16716 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16717 PyObject *resultobj = 0;
16718 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16719 wxString *result = 0 ;
16720 void *argp1 = 0 ;
16721 int res1 = 0 ;
16722 PyObject *swig_obj[1] ;
16723
16724 if (!args) SWIG_fail;
16725 swig_obj[0] = args;
16726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16727 if (!SWIG_IsOK(res1)) {
16728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16729 }
16730 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16731 {
16732 PyThreadState* __tstate = wxPyBeginAllowThreads();
16733 {
16734 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16735 result = (wxString *) &_result_ref;
16736 }
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 {
16741 #if wxUSE_UNICODE
16742 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16743 #else
16744 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16745 #endif
16746 }
16747 return resultobj;
16748 fail:
16749 return NULL;
16750 }
16751
16752
16753 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16754 PyObject *resultobj = 0;
16755 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16756 wxString *result = 0 ;
16757 void *argp1 = 0 ;
16758 int res1 = 0 ;
16759 PyObject *swig_obj[1] ;
16760
16761 if (!args) SWIG_fail;
16762 swig_obj[0] = args;
16763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16764 if (!SWIG_IsOK(res1)) {
16765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16766 }
16767 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 {
16771 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16772 result = (wxString *) &_result_ref;
16773 }
16774 wxPyEndAllowThreads(__tstate);
16775 if (PyErr_Occurred()) SWIG_fail;
16776 }
16777 {
16778 #if wxUSE_UNICODE
16779 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16780 #else
16781 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16782 #endif
16783 }
16784 return resultobj;
16785 fail:
16786 return NULL;
16787 }
16788
16789
16790 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16791 PyObject *resultobj = 0;
16792 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16793 wxString *result = 0 ;
16794 void *argp1 = 0 ;
16795 int res1 = 0 ;
16796 PyObject *swig_obj[1] ;
16797
16798 if (!args) SWIG_fail;
16799 swig_obj[0] = args;
16800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16801 if (!SWIG_IsOK(res1)) {
16802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16803 }
16804 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 {
16808 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16809 result = (wxString *) &_result_ref;
16810 }
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 {
16815 #if wxUSE_UNICODE
16816 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16817 #else
16818 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16819 #endif
16820 }
16821 return resultobj;
16822 fail:
16823 return NULL;
16824 }
16825
16826
16827 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16828 PyObject *resultobj = 0;
16829 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16830 wxArrayString *result = 0 ;
16831 void *argp1 = 0 ;
16832 int res1 = 0 ;
16833 PyObject *swig_obj[1] ;
16834
16835 if (!args) SWIG_fail;
16836 swig_obj[0] = args;
16837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16838 if (!SWIG_IsOK(res1)) {
16839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16840 }
16841 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 {
16845 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16846 result = (wxArrayString *) &_result_ref;
16847 }
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 {
16852 resultobj = wxArrayString2PyList_helper(*result);
16853 }
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16861 PyObject *resultobj = 0;
16862 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16863 size_t result;
16864 void *argp1 = 0 ;
16865 int res1 = 0 ;
16866 PyObject *swig_obj[1] ;
16867
16868 if (!args) SWIG_fail;
16869 swig_obj[0] = args;
16870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16871 if (!SWIG_IsOK(res1)) {
16872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16873 }
16874 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16875 {
16876 PyThreadState* __tstate = wxPyBeginAllowThreads();
16877 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16878 wxPyEndAllowThreads(__tstate);
16879 if (PyErr_Occurred()) SWIG_fail;
16880 }
16881 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16882 return resultobj;
16883 fail:
16884 return NULL;
16885 }
16886
16887
16888 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16889 PyObject *resultobj = 0;
16890 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16891 wxString *result = 0 ;
16892 void *argp1 = 0 ;
16893 int res1 = 0 ;
16894 PyObject *swig_obj[1] ;
16895
16896 if (!args) SWIG_fail;
16897 swig_obj[0] = args;
16898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16899 if (!SWIG_IsOK(res1)) {
16900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16901 }
16902 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16903 {
16904 PyThreadState* __tstate = wxPyBeginAllowThreads();
16905 {
16906 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16907 result = (wxString *) &_result_ref;
16908 }
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 {
16913 #if wxUSE_UNICODE
16914 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16915 #else
16916 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16917 #endif
16918 }
16919 return resultobj;
16920 fail:
16921 return NULL;
16922 }
16923
16924
16925 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16926 PyObject *resultobj = 0;
16927 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16928 int result;
16929 void *argp1 = 0 ;
16930 int res1 = 0 ;
16931 PyObject *swig_obj[1] ;
16932
16933 if (!args) SWIG_fail;
16934 swig_obj[0] = args;
16935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16936 if (!SWIG_IsOK(res1)) {
16937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16938 }
16939 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 resultobj = SWIG_From_int(static_cast< int >(result));
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16954 PyObject *obj;
16955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16956 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16957 return SWIG_Py_Void();
16958 }
16959
16960 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16961 return SWIG_Python_InitShadowInstance(args);
16962 }
16963
16964 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj = 0;
16966 wxFileTypeInfo *arg1 = 0 ;
16967 wxFileType *result = 0 ;
16968 void *argp1 = 0 ;
16969 int res1 = 0 ;
16970 PyObject * obj0 = 0 ;
16971 char * kwnames[] = {
16972 (char *) "ftInfo", NULL
16973 };
16974
16975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16976 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16977 if (!SWIG_IsOK(res1)) {
16978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16979 }
16980 if (!argp1) {
16981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16982 }
16983 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16987 wxPyEndAllowThreads(__tstate);
16988 if (PyErr_Occurred()) SWIG_fail;
16989 }
16990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16991 return resultobj;
16992 fail:
16993 return NULL;
16994 }
16995
16996
16997 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16998 PyObject *resultobj = 0;
16999 wxFileType *arg1 = (wxFileType *) 0 ;
17000 void *argp1 = 0 ;
17001 int res1 = 0 ;
17002 PyObject *swig_obj[1] ;
17003
17004 if (!args) SWIG_fail;
17005 swig_obj[0] = args;
17006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
17007 if (!SWIG_IsOK(res1)) {
17008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17009 }
17010 arg1 = reinterpret_cast< wxFileType * >(argp1);
17011 {
17012 PyThreadState* __tstate = wxPyBeginAllowThreads();
17013 delete arg1;
17014
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 resultobj = SWIG_Py_Void();
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17026 PyObject *resultobj = 0;
17027 wxFileType *arg1 = (wxFileType *) 0 ;
17028 PyObject *result = 0 ;
17029 void *argp1 = 0 ;
17030 int res1 = 0 ;
17031 PyObject *swig_obj[1] ;
17032
17033 if (!args) SWIG_fail;
17034 swig_obj[0] = args;
17035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17036 if (!SWIG_IsOK(res1)) {
17037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17038 }
17039 arg1 = reinterpret_cast< wxFileType * >(argp1);
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 result = (PyObject *)wxFileType_GetMimeType(arg1);
17043 wxPyEndAllowThreads(__tstate);
17044 if (PyErr_Occurred()) SWIG_fail;
17045 }
17046 resultobj = result;
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17054 PyObject *resultobj = 0;
17055 wxFileType *arg1 = (wxFileType *) 0 ;
17056 PyObject *result = 0 ;
17057 void *argp1 = 0 ;
17058 int res1 = 0 ;
17059 PyObject *swig_obj[1] ;
17060
17061 if (!args) SWIG_fail;
17062 swig_obj[0] = args;
17063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17064 if (!SWIG_IsOK(res1)) {
17065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17066 }
17067 arg1 = reinterpret_cast< wxFileType * >(argp1);
17068 {
17069 PyThreadState* __tstate = wxPyBeginAllowThreads();
17070 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17071 wxPyEndAllowThreads(__tstate);
17072 if (PyErr_Occurred()) SWIG_fail;
17073 }
17074 resultobj = result;
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17082 PyObject *resultobj = 0;
17083 wxFileType *arg1 = (wxFileType *) 0 ;
17084 PyObject *result = 0 ;
17085 void *argp1 = 0 ;
17086 int res1 = 0 ;
17087 PyObject *swig_obj[1] ;
17088
17089 if (!args) SWIG_fail;
17090 swig_obj[0] = args;
17091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17092 if (!SWIG_IsOK(res1)) {
17093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17094 }
17095 arg1 = reinterpret_cast< wxFileType * >(argp1);
17096 {
17097 PyThreadState* __tstate = wxPyBeginAllowThreads();
17098 result = (PyObject *)wxFileType_GetExtensions(arg1);
17099 wxPyEndAllowThreads(__tstate);
17100 if (PyErr_Occurred()) SWIG_fail;
17101 }
17102 resultobj = result;
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17110 PyObject *resultobj = 0;
17111 wxFileType *arg1 = (wxFileType *) 0 ;
17112 wxIcon *result = 0 ;
17113 void *argp1 = 0 ;
17114 int res1 = 0 ;
17115 PyObject *swig_obj[1] ;
17116
17117 if (!args) SWIG_fail;
17118 swig_obj[0] = args;
17119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17120 if (!SWIG_IsOK(res1)) {
17121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17122 }
17123 arg1 = reinterpret_cast< wxFileType * >(argp1);
17124 {
17125 PyThreadState* __tstate = wxPyBeginAllowThreads();
17126 result = (wxIcon *)wxFileType_GetIcon(arg1);
17127 wxPyEndAllowThreads(__tstate);
17128 if (PyErr_Occurred()) SWIG_fail;
17129 }
17130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17138 PyObject *resultobj = 0;
17139 wxFileType *arg1 = (wxFileType *) 0 ;
17140 PyObject *result = 0 ;
17141 void *argp1 = 0 ;
17142 int res1 = 0 ;
17143 PyObject *swig_obj[1] ;
17144
17145 if (!args) SWIG_fail;
17146 swig_obj[0] = args;
17147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17148 if (!SWIG_IsOK(res1)) {
17149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
17150 }
17151 arg1 = reinterpret_cast< wxFileType * >(argp1);
17152 {
17153 PyThreadState* __tstate = wxPyBeginAllowThreads();
17154 result = (PyObject *)wxFileType_GetIconInfo(arg1);
17155 wxPyEndAllowThreads(__tstate);
17156 if (PyErr_Occurred()) SWIG_fail;
17157 }
17158 resultobj = result;
17159 return resultobj;
17160 fail:
17161 return NULL;
17162 }
17163
17164
17165 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17166 PyObject *resultobj = 0;
17167 wxFileType *arg1 = (wxFileType *) 0 ;
17168 PyObject *result = 0 ;
17169 void *argp1 = 0 ;
17170 int res1 = 0 ;
17171 PyObject *swig_obj[1] ;
17172
17173 if (!args) SWIG_fail;
17174 swig_obj[0] = args;
17175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17176 if (!SWIG_IsOK(res1)) {
17177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17178 }
17179 arg1 = reinterpret_cast< wxFileType * >(argp1);
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (PyObject *)wxFileType_GetDescription(arg1);
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = result;
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj = 0;
17195 wxFileType *arg1 = (wxFileType *) 0 ;
17196 wxString *arg2 = 0 ;
17197 wxString const &arg3_defvalue = wxPyEmptyString ;
17198 wxString *arg3 = (wxString *) &arg3_defvalue ;
17199 PyObject *result = 0 ;
17200 void *argp1 = 0 ;
17201 int res1 = 0 ;
17202 bool temp2 = false ;
17203 bool temp3 = false ;
17204 PyObject * obj0 = 0 ;
17205 PyObject * obj1 = 0 ;
17206 PyObject * obj2 = 0 ;
17207 char * kwnames[] = {
17208 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17209 };
17210
17211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17213 if (!SWIG_IsOK(res1)) {
17214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17215 }
17216 arg1 = reinterpret_cast< wxFileType * >(argp1);
17217 {
17218 arg2 = wxString_in_helper(obj1);
17219 if (arg2 == NULL) SWIG_fail;
17220 temp2 = true;
17221 }
17222 if (obj2) {
17223 {
17224 arg3 = wxString_in_helper(obj2);
17225 if (arg3 == NULL) SWIG_fail;
17226 temp3 = true;
17227 }
17228 }
17229 {
17230 PyThreadState* __tstate = wxPyBeginAllowThreads();
17231 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17232 wxPyEndAllowThreads(__tstate);
17233 if (PyErr_Occurred()) SWIG_fail;
17234 }
17235 resultobj = result;
17236 {
17237 if (temp2)
17238 delete arg2;
17239 }
17240 {
17241 if (temp3)
17242 delete arg3;
17243 }
17244 return resultobj;
17245 fail:
17246 {
17247 if (temp2)
17248 delete arg2;
17249 }
17250 {
17251 if (temp3)
17252 delete arg3;
17253 }
17254 return NULL;
17255 }
17256
17257
17258 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17259 PyObject *resultobj = 0;
17260 wxFileType *arg1 = (wxFileType *) 0 ;
17261 wxString *arg2 = 0 ;
17262 wxString const &arg3_defvalue = wxPyEmptyString ;
17263 wxString *arg3 = (wxString *) &arg3_defvalue ;
17264 PyObject *result = 0 ;
17265 void *argp1 = 0 ;
17266 int res1 = 0 ;
17267 bool temp2 = false ;
17268 bool temp3 = false ;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271 PyObject * obj2 = 0 ;
17272 char * kwnames[] = {
17273 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17274 };
17275
17276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17278 if (!SWIG_IsOK(res1)) {
17279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17280 }
17281 arg1 = reinterpret_cast< wxFileType * >(argp1);
17282 {
17283 arg2 = wxString_in_helper(obj1);
17284 if (arg2 == NULL) SWIG_fail;
17285 temp2 = true;
17286 }
17287 if (obj2) {
17288 {
17289 arg3 = wxString_in_helper(obj2);
17290 if (arg3 == NULL) SWIG_fail;
17291 temp3 = true;
17292 }
17293 }
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 resultobj = result;
17301 {
17302 if (temp2)
17303 delete arg2;
17304 }
17305 {
17306 if (temp3)
17307 delete arg3;
17308 }
17309 return resultobj;
17310 fail:
17311 {
17312 if (temp2)
17313 delete arg2;
17314 }
17315 {
17316 if (temp3)
17317 delete arg3;
17318 }
17319 return NULL;
17320 }
17321
17322
17323 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17324 PyObject *resultobj = 0;
17325 wxFileType *arg1 = (wxFileType *) 0 ;
17326 wxString *arg2 = 0 ;
17327 wxString const &arg3_defvalue = wxPyEmptyString ;
17328 wxString *arg3 = (wxString *) &arg3_defvalue ;
17329 PyObject *result = 0 ;
17330 void *argp1 = 0 ;
17331 int res1 = 0 ;
17332 bool temp2 = false ;
17333 bool temp3 = false ;
17334 PyObject * obj0 = 0 ;
17335 PyObject * obj1 = 0 ;
17336 PyObject * obj2 = 0 ;
17337 char * kwnames[] = {
17338 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17339 };
17340
17341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17343 if (!SWIG_IsOK(res1)) {
17344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17345 }
17346 arg1 = reinterpret_cast< wxFileType * >(argp1);
17347 {
17348 arg2 = wxString_in_helper(obj1);
17349 if (arg2 == NULL) SWIG_fail;
17350 temp2 = true;
17351 }
17352 if (obj2) {
17353 {
17354 arg3 = wxString_in_helper(obj2);
17355 if (arg3 == NULL) SWIG_fail;
17356 temp3 = true;
17357 }
17358 }
17359 {
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 resultobj = result;
17366 {
17367 if (temp2)
17368 delete arg2;
17369 }
17370 {
17371 if (temp3)
17372 delete arg3;
17373 }
17374 return resultobj;
17375 fail:
17376 {
17377 if (temp2)
17378 delete arg2;
17379 }
17380 {
17381 if (temp3)
17382 delete arg3;
17383 }
17384 return NULL;
17385 }
17386
17387
17388 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj = 0;
17390 wxFileType *arg1 = (wxFileType *) 0 ;
17391 wxString *arg2 = 0 ;
17392 wxString *arg3 = 0 ;
17393 bool arg4 = (bool) true ;
17394 bool result;
17395 void *argp1 = 0 ;
17396 int res1 = 0 ;
17397 bool temp2 = false ;
17398 bool temp3 = false ;
17399 bool val4 ;
17400 int ecode4 = 0 ;
17401 PyObject * obj0 = 0 ;
17402 PyObject * obj1 = 0 ;
17403 PyObject * obj2 = 0 ;
17404 PyObject * obj3 = 0 ;
17405 char * kwnames[] = {
17406 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17407 };
17408
17409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17411 if (!SWIG_IsOK(res1)) {
17412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17413 }
17414 arg1 = reinterpret_cast< wxFileType * >(argp1);
17415 {
17416 arg2 = wxString_in_helper(obj1);
17417 if (arg2 == NULL) SWIG_fail;
17418 temp2 = true;
17419 }
17420 {
17421 arg3 = wxString_in_helper(obj2);
17422 if (arg3 == NULL) SWIG_fail;
17423 temp3 = true;
17424 }
17425 if (obj3) {
17426 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17427 if (!SWIG_IsOK(ecode4)) {
17428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17429 }
17430 arg4 = static_cast< bool >(val4);
17431 }
17432 {
17433 PyThreadState* __tstate = wxPyBeginAllowThreads();
17434 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17435 wxPyEndAllowThreads(__tstate);
17436 if (PyErr_Occurred()) SWIG_fail;
17437 }
17438 {
17439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17440 }
17441 {
17442 if (temp2)
17443 delete arg2;
17444 }
17445 {
17446 if (temp3)
17447 delete arg3;
17448 }
17449 return resultobj;
17450 fail:
17451 {
17452 if (temp2)
17453 delete arg2;
17454 }
17455 {
17456 if (temp3)
17457 delete arg3;
17458 }
17459 return NULL;
17460 }
17461
17462
17463 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17464 PyObject *resultobj = 0;
17465 wxFileType *arg1 = (wxFileType *) 0 ;
17466 wxString const &arg2_defvalue = wxPyEmptyString ;
17467 wxString *arg2 = (wxString *) &arg2_defvalue ;
17468 int arg3 = (int) 0 ;
17469 bool result;
17470 void *argp1 = 0 ;
17471 int res1 = 0 ;
17472 bool temp2 = false ;
17473 int val3 ;
17474 int ecode3 = 0 ;
17475 PyObject * obj0 = 0 ;
17476 PyObject * obj1 = 0 ;
17477 PyObject * obj2 = 0 ;
17478 char * kwnames[] = {
17479 (char *) "self",(char *) "cmd",(char *) "index", NULL
17480 };
17481
17482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17484 if (!SWIG_IsOK(res1)) {
17485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17486 }
17487 arg1 = reinterpret_cast< wxFileType * >(argp1);
17488 if (obj1) {
17489 {
17490 arg2 = wxString_in_helper(obj1);
17491 if (arg2 == NULL) SWIG_fail;
17492 temp2 = true;
17493 }
17494 }
17495 if (obj2) {
17496 ecode3 = SWIG_AsVal_int(obj2, &val3);
17497 if (!SWIG_IsOK(ecode3)) {
17498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17499 }
17500 arg3 = static_cast< int >(val3);
17501 }
17502 {
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17505 wxPyEndAllowThreads(__tstate);
17506 if (PyErr_Occurred()) SWIG_fail;
17507 }
17508 {
17509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17510 }
17511 {
17512 if (temp2)
17513 delete arg2;
17514 }
17515 return resultobj;
17516 fail:
17517 {
17518 if (temp2)
17519 delete arg2;
17520 }
17521 return NULL;
17522 }
17523
17524
17525 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17526 PyObject *resultobj = 0;
17527 wxFileType *arg1 = (wxFileType *) 0 ;
17528 bool result;
17529 void *argp1 = 0 ;
17530 int res1 = 0 ;
17531 PyObject *swig_obj[1] ;
17532
17533 if (!args) SWIG_fail;
17534 swig_obj[0] = args;
17535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17536 if (!SWIG_IsOK(res1)) {
17537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17538 }
17539 arg1 = reinterpret_cast< wxFileType * >(argp1);
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = (bool)(arg1)->Unassociate();
17543 wxPyEndAllowThreads(__tstate);
17544 if (PyErr_Occurred()) SWIG_fail;
17545 }
17546 {
17547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17548 }
17549 return resultobj;
17550 fail:
17551 return NULL;
17552 }
17553
17554
17555 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj = 0;
17557 wxString *arg1 = 0 ;
17558 wxString *arg2 = 0 ;
17559 wxString const &arg3_defvalue = wxPyEmptyString ;
17560 wxString *arg3 = (wxString *) &arg3_defvalue ;
17561 wxString result;
17562 bool temp1 = false ;
17563 bool temp2 = false ;
17564 bool temp3 = false ;
17565 PyObject * obj0 = 0 ;
17566 PyObject * obj1 = 0 ;
17567 PyObject * obj2 = 0 ;
17568 char * kwnames[] = {
17569 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17570 };
17571
17572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17573 {
17574 arg1 = wxString_in_helper(obj0);
17575 if (arg1 == NULL) SWIG_fail;
17576 temp1 = true;
17577 }
17578 {
17579 arg2 = wxString_in_helper(obj1);
17580 if (arg2 == NULL) SWIG_fail;
17581 temp2 = true;
17582 }
17583 if (obj2) {
17584 {
17585 arg3 = wxString_in_helper(obj2);
17586 if (arg3 == NULL) SWIG_fail;
17587 temp3 = true;
17588 }
17589 }
17590 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17593 wxPyEndAllowThreads(__tstate);
17594 if (PyErr_Occurred()) SWIG_fail;
17595 }
17596 {
17597 #if wxUSE_UNICODE
17598 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17599 #else
17600 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17601 #endif
17602 }
17603 {
17604 if (temp1)
17605 delete arg1;
17606 }
17607 {
17608 if (temp2)
17609 delete arg2;
17610 }
17611 {
17612 if (temp3)
17613 delete arg3;
17614 }
17615 return resultobj;
17616 fail:
17617 {
17618 if (temp1)
17619 delete arg1;
17620 }
17621 {
17622 if (temp2)
17623 delete arg2;
17624 }
17625 {
17626 if (temp3)
17627 delete arg3;
17628 }
17629 return NULL;
17630 }
17631
17632
17633 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17634 PyObject *obj;
17635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17636 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17637 return SWIG_Py_Void();
17638 }
17639
17640 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17641 return SWIG_Python_InitShadowInstance(args);
17642 }
17643
17644 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17645 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17646 return 1;
17647 }
17648
17649
17650 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17651 PyObject *pyobj = 0;
17652
17653 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17654 return pyobj;
17655 }
17656
17657
17658 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17659 PyObject *resultobj = 0;
17660 wxString *arg1 = 0 ;
17661 wxString *arg2 = 0 ;
17662 bool result;
17663 bool temp1 = false ;
17664 bool temp2 = false ;
17665 PyObject * obj0 = 0 ;
17666 PyObject * obj1 = 0 ;
17667 char * kwnames[] = {
17668 (char *) "mimeType",(char *) "wildcard", NULL
17669 };
17670
17671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17672 {
17673 arg1 = wxString_in_helper(obj0);
17674 if (arg1 == NULL) SWIG_fail;
17675 temp1 = true;
17676 }
17677 {
17678 arg2 = wxString_in_helper(obj1);
17679 if (arg2 == NULL) SWIG_fail;
17680 temp2 = true;
17681 }
17682 {
17683 PyThreadState* __tstate = wxPyBeginAllowThreads();
17684 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17685 wxPyEndAllowThreads(__tstate);
17686 if (PyErr_Occurred()) SWIG_fail;
17687 }
17688 {
17689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17690 }
17691 {
17692 if (temp1)
17693 delete arg1;
17694 }
17695 {
17696 if (temp2)
17697 delete arg2;
17698 }
17699 return resultobj;
17700 fail:
17701 {
17702 if (temp1)
17703 delete arg1;
17704 }
17705 {
17706 if (temp2)
17707 delete arg2;
17708 }
17709 return NULL;
17710 }
17711
17712
17713 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17714 PyObject *resultobj = 0;
17715 wxMimeTypesManager *result = 0 ;
17716
17717 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17718 {
17719 PyThreadState* __tstate = wxPyBeginAllowThreads();
17720 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17725 return resultobj;
17726 fail:
17727 return NULL;
17728 }
17729
17730
17731 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj = 0;
17733 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17734 int arg2 = (int) wxMAILCAP_ALL ;
17735 wxString const &arg3_defvalue = wxPyEmptyString ;
17736 wxString *arg3 = (wxString *) &arg3_defvalue ;
17737 void *argp1 = 0 ;
17738 int res1 = 0 ;
17739 int val2 ;
17740 int ecode2 = 0 ;
17741 bool temp3 = false ;
17742 PyObject * obj0 = 0 ;
17743 PyObject * obj1 = 0 ;
17744 PyObject * obj2 = 0 ;
17745 char * kwnames[] = {
17746 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17747 };
17748
17749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17751 if (!SWIG_IsOK(res1)) {
17752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17753 }
17754 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17755 if (obj1) {
17756 ecode2 = SWIG_AsVal_int(obj1, &val2);
17757 if (!SWIG_IsOK(ecode2)) {
17758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17759 }
17760 arg2 = static_cast< int >(val2);
17761 }
17762 if (obj2) {
17763 {
17764 arg3 = wxString_in_helper(obj2);
17765 if (arg3 == NULL) SWIG_fail;
17766 temp3 = true;
17767 }
17768 }
17769 {
17770 PyThreadState* __tstate = wxPyBeginAllowThreads();
17771 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17772 wxPyEndAllowThreads(__tstate);
17773 if (PyErr_Occurred()) SWIG_fail;
17774 }
17775 resultobj = SWIG_Py_Void();
17776 {
17777 if (temp3)
17778 delete arg3;
17779 }
17780 return resultobj;
17781 fail:
17782 {
17783 if (temp3)
17784 delete arg3;
17785 }
17786 return NULL;
17787 }
17788
17789
17790 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791 PyObject *resultobj = 0;
17792 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17793 void *argp1 = 0 ;
17794 int res1 = 0 ;
17795 PyObject *swig_obj[1] ;
17796
17797 if (!args) SWIG_fail;
17798 swig_obj[0] = args;
17799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17800 if (!SWIG_IsOK(res1)) {
17801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17802 }
17803 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17804 {
17805 PyThreadState* __tstate = wxPyBeginAllowThreads();
17806 (arg1)->ClearData();
17807 wxPyEndAllowThreads(__tstate);
17808 if (PyErr_Occurred()) SWIG_fail;
17809 }
17810 resultobj = SWIG_Py_Void();
17811 return resultobj;
17812 fail:
17813 return NULL;
17814 }
17815
17816
17817 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17818 PyObject *resultobj = 0;
17819 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17820 wxString *arg2 = 0 ;
17821 wxFileType *result = 0 ;
17822 void *argp1 = 0 ;
17823 int res1 = 0 ;
17824 bool temp2 = false ;
17825 PyObject * obj0 = 0 ;
17826 PyObject * obj1 = 0 ;
17827 char * kwnames[] = {
17828 (char *) "self",(char *) "ext", NULL
17829 };
17830
17831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17833 if (!SWIG_IsOK(res1)) {
17834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17835 }
17836 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17837 {
17838 arg2 = wxString_in_helper(obj1);
17839 if (arg2 == NULL) SWIG_fail;
17840 temp2 = true;
17841 }
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17849 {
17850 if (temp2)
17851 delete arg2;
17852 }
17853 return resultobj;
17854 fail:
17855 {
17856 if (temp2)
17857 delete arg2;
17858 }
17859 return NULL;
17860 }
17861
17862
17863 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17864 PyObject *resultobj = 0;
17865 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17866 wxString *arg2 = 0 ;
17867 wxFileType *result = 0 ;
17868 void *argp1 = 0 ;
17869 int res1 = 0 ;
17870 bool temp2 = false ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 char * kwnames[] = {
17874 (char *) "self",(char *) "mimeType", NULL
17875 };
17876
17877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17879 if (!SWIG_IsOK(res1)) {
17880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17881 }
17882 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17883 {
17884 arg2 = wxString_in_helper(obj1);
17885 if (arg2 == NULL) SWIG_fail;
17886 temp2 = true;
17887 }
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17895 {
17896 if (temp2)
17897 delete arg2;
17898 }
17899 return resultobj;
17900 fail:
17901 {
17902 if (temp2)
17903 delete arg2;
17904 }
17905 return NULL;
17906 }
17907
17908
17909 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj = 0;
17911 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17912 wxString *arg2 = 0 ;
17913 bool arg3 = (bool) false ;
17914 bool result;
17915 void *argp1 = 0 ;
17916 int res1 = 0 ;
17917 bool temp2 = false ;
17918 bool val3 ;
17919 int ecode3 = 0 ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 PyObject * obj2 = 0 ;
17923 char * kwnames[] = {
17924 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17925 };
17926
17927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17931 }
17932 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17933 {
17934 arg2 = wxString_in_helper(obj1);
17935 if (arg2 == NULL) SWIG_fail;
17936 temp2 = true;
17937 }
17938 if (obj2) {
17939 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17940 if (!SWIG_IsOK(ecode3)) {
17941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17942 }
17943 arg3 = static_cast< bool >(val3);
17944 }
17945 {
17946 PyThreadState* __tstate = wxPyBeginAllowThreads();
17947 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 {
17952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17953 }
17954 {
17955 if (temp2)
17956 delete arg2;
17957 }
17958 return resultobj;
17959 fail:
17960 {
17961 if (temp2)
17962 delete arg2;
17963 }
17964 return NULL;
17965 }
17966
17967
17968 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17969 PyObject *resultobj = 0;
17970 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17971 wxString *arg2 = 0 ;
17972 bool result;
17973 void *argp1 = 0 ;
17974 int res1 = 0 ;
17975 bool temp2 = false ;
17976 PyObject * obj0 = 0 ;
17977 PyObject * obj1 = 0 ;
17978 char * kwnames[] = {
17979 (char *) "self",(char *) "filename", NULL
17980 };
17981
17982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17984 if (!SWIG_IsOK(res1)) {
17985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17986 }
17987 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17988 {
17989 arg2 = wxString_in_helper(obj1);
17990 if (arg2 == NULL) SWIG_fail;
17991 temp2 = true;
17992 }
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17996 wxPyEndAllowThreads(__tstate);
17997 if (PyErr_Occurred()) SWIG_fail;
17998 }
17999 {
18000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18001 }
18002 {
18003 if (temp2)
18004 delete arg2;
18005 }
18006 return resultobj;
18007 fail:
18008 {
18009 if (temp2)
18010 delete arg2;
18011 }
18012 return NULL;
18013 }
18014
18015
18016 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18017 PyObject *resultobj = 0;
18018 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18019 PyObject *result = 0 ;
18020 void *argp1 = 0 ;
18021 int res1 = 0 ;
18022 PyObject *swig_obj[1] ;
18023
18024 if (!args) SWIG_fail;
18025 swig_obj[0] = args;
18026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18027 if (!SWIG_IsOK(res1)) {
18028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18029 }
18030 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18031 {
18032 PyThreadState* __tstate = wxPyBeginAllowThreads();
18033 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18034 wxPyEndAllowThreads(__tstate);
18035 if (PyErr_Occurred()) SWIG_fail;
18036 }
18037 resultobj = result;
18038 return resultobj;
18039 fail:
18040 return NULL;
18041 }
18042
18043
18044 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18045 PyObject *resultobj = 0;
18046 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18047 wxFileTypeInfo *arg2 = 0 ;
18048 void *argp1 = 0 ;
18049 int res1 = 0 ;
18050 void *argp2 = 0 ;
18051 int res2 = 0 ;
18052 PyObject * obj0 = 0 ;
18053 PyObject * obj1 = 0 ;
18054 char * kwnames[] = {
18055 (char *) "self",(char *) "ft", NULL
18056 };
18057
18058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18060 if (!SWIG_IsOK(res1)) {
18061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18062 }
18063 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18064 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18065 if (!SWIG_IsOK(res2)) {
18066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18067 }
18068 if (!argp2) {
18069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18070 }
18071 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18072 {
18073 PyThreadState* __tstate = wxPyBeginAllowThreads();
18074 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18075 wxPyEndAllowThreads(__tstate);
18076 if (PyErr_Occurred()) SWIG_fail;
18077 }
18078 resultobj = SWIG_Py_Void();
18079 return resultobj;
18080 fail:
18081 return NULL;
18082 }
18083
18084
18085 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18086 PyObject *resultobj = 0;
18087 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18088 wxFileTypeInfo *arg2 = 0 ;
18089 wxFileType *result = 0 ;
18090 void *argp1 = 0 ;
18091 int res1 = 0 ;
18092 void *argp2 = 0 ;
18093 int res2 = 0 ;
18094 PyObject * obj0 = 0 ;
18095 PyObject * obj1 = 0 ;
18096 char * kwnames[] = {
18097 (char *) "self",(char *) "ftInfo", NULL
18098 };
18099
18100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18102 if (!SWIG_IsOK(res1)) {
18103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18104 }
18105 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18107 if (!SWIG_IsOK(res2)) {
18108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18109 }
18110 if (!argp2) {
18111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18112 }
18113 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18128 PyObject *resultobj = 0;
18129 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18130 wxFileType *arg2 = (wxFileType *) 0 ;
18131 bool result;
18132 void *argp1 = 0 ;
18133 int res1 = 0 ;
18134 void *argp2 = 0 ;
18135 int res2 = 0 ;
18136 PyObject * obj0 = 0 ;
18137 PyObject * obj1 = 0 ;
18138 char * kwnames[] = {
18139 (char *) "self",(char *) "ft", NULL
18140 };
18141
18142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
18143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18144 if (!SWIG_IsOK(res1)) {
18145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18146 }
18147 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
18149 if (!SWIG_IsOK(res2)) {
18150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
18151 }
18152 arg2 = reinterpret_cast< wxFileType * >(argp2);
18153 {
18154 PyThreadState* __tstate = wxPyBeginAllowThreads();
18155 result = (bool)(arg1)->Unassociate(arg2);
18156 wxPyEndAllowThreads(__tstate);
18157 if (PyErr_Occurred()) SWIG_fail;
18158 }
18159 {
18160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18161 }
18162 return resultobj;
18163 fail:
18164 return NULL;
18165 }
18166
18167
18168 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18169 PyObject *resultobj = 0;
18170 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18171 void *argp1 = 0 ;
18172 int res1 = 0 ;
18173 PyObject *swig_obj[1] ;
18174
18175 if (!args) SWIG_fail;
18176 swig_obj[0] = args;
18177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18178 if (!SWIG_IsOK(res1)) {
18179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18180 }
18181 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 delete arg1;
18185
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 resultobj = SWIG_Py_Void();
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18197 PyObject *obj;
18198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18199 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18200 return SWIG_Py_Void();
18201 }
18202
18203 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18204 return SWIG_Python_InitShadowInstance(args);
18205 }
18206
18207 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18208 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18209 return 1;
18210 }
18211
18212
18213 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18214 PyObject *pyobj = 0;
18215
18216 {
18217 #if wxUSE_UNICODE
18218 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18219 #else
18220 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18221 #endif
18222 }
18223 return pyobj;
18224 }
18225
18226
18227 SWIGINTERN int ART_MENU_set(PyObject *) {
18228 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18229 return 1;
18230 }
18231
18232
18233 SWIGINTERN PyObject *ART_MENU_get(void) {
18234 PyObject *pyobj = 0;
18235
18236 {
18237 #if wxUSE_UNICODE
18238 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18239 #else
18240 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18241 #endif
18242 }
18243 return pyobj;
18244 }
18245
18246
18247 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18248 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18249 return 1;
18250 }
18251
18252
18253 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18254 PyObject *pyobj = 0;
18255
18256 {
18257 #if wxUSE_UNICODE
18258 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18259 #else
18260 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18261 #endif
18262 }
18263 return pyobj;
18264 }
18265
18266
18267 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18268 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18269 return 1;
18270 }
18271
18272
18273 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18274 PyObject *pyobj = 0;
18275
18276 {
18277 #if wxUSE_UNICODE
18278 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18279 #else
18280 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18281 #endif
18282 }
18283 return pyobj;
18284 }
18285
18286
18287 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18288 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18289 return 1;
18290 }
18291
18292
18293 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18294 PyObject *pyobj = 0;
18295
18296 {
18297 #if wxUSE_UNICODE
18298 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18299 #else
18300 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18301 #endif
18302 }
18303 return pyobj;
18304 }
18305
18306
18307 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18308 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18309 return 1;
18310 }
18311
18312
18313 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18314 PyObject *pyobj = 0;
18315
18316 {
18317 #if wxUSE_UNICODE
18318 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18319 #else
18320 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18321 #endif
18322 }
18323 return pyobj;
18324 }
18325
18326
18327 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18328 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18329 return 1;
18330 }
18331
18332
18333 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18334 PyObject *pyobj = 0;
18335
18336 {
18337 #if wxUSE_UNICODE
18338 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18339 #else
18340 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18341 #endif
18342 }
18343 return pyobj;
18344 }
18345
18346
18347 SWIGINTERN int ART_OTHER_set(PyObject *) {
18348 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18349 return 1;
18350 }
18351
18352
18353 SWIGINTERN PyObject *ART_OTHER_get(void) {
18354 PyObject *pyobj = 0;
18355
18356 {
18357 #if wxUSE_UNICODE
18358 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18359 #else
18360 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18361 #endif
18362 }
18363 return pyobj;
18364 }
18365
18366
18367 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18368 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18369 return 1;
18370 }
18371
18372
18373 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18374 PyObject *pyobj = 0;
18375
18376 {
18377 #if wxUSE_UNICODE
18378 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18379 #else
18380 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18381 #endif
18382 }
18383 return pyobj;
18384 }
18385
18386
18387 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18388 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18389 return 1;
18390 }
18391
18392
18393 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18394 PyObject *pyobj = 0;
18395
18396 {
18397 #if wxUSE_UNICODE
18398 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18399 #else
18400 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18401 #endif
18402 }
18403 return pyobj;
18404 }
18405
18406
18407 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18408 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18409 return 1;
18410 }
18411
18412
18413 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18414 PyObject *pyobj = 0;
18415
18416 {
18417 #if wxUSE_UNICODE
18418 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18419 #else
18420 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18421 #endif
18422 }
18423 return pyobj;
18424 }
18425
18426
18427 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18428 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18429 return 1;
18430 }
18431
18432
18433 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18434 PyObject *pyobj = 0;
18435
18436 {
18437 #if wxUSE_UNICODE
18438 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18439 #else
18440 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18441 #endif
18442 }
18443 return pyobj;
18444 }
18445
18446
18447 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18448 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18449 return 1;
18450 }
18451
18452
18453 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18454 PyObject *pyobj = 0;
18455
18456 {
18457 #if wxUSE_UNICODE
18458 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18459 #else
18460 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18461 #endif
18462 }
18463 return pyobj;
18464 }
18465
18466
18467 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18468 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18469 return 1;
18470 }
18471
18472
18473 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18474 PyObject *pyobj = 0;
18475
18476 {
18477 #if wxUSE_UNICODE
18478 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18479 #else
18480 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18481 #endif
18482 }
18483 return pyobj;
18484 }
18485
18486
18487 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18488 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18489 return 1;
18490 }
18491
18492
18493 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18494 PyObject *pyobj = 0;
18495
18496 {
18497 #if wxUSE_UNICODE
18498 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18499 #else
18500 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18501 #endif
18502 }
18503 return pyobj;
18504 }
18505
18506
18507 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18508 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18509 return 1;
18510 }
18511
18512
18513 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18514 PyObject *pyobj = 0;
18515
18516 {
18517 #if wxUSE_UNICODE
18518 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18519 #else
18520 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18521 #endif
18522 }
18523 return pyobj;
18524 }
18525
18526
18527 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18528 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18529 return 1;
18530 }
18531
18532
18533 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18534 PyObject *pyobj = 0;
18535
18536 {
18537 #if wxUSE_UNICODE
18538 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18539 #else
18540 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18541 #endif
18542 }
18543 return pyobj;
18544 }
18545
18546
18547 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18548 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18549 return 1;
18550 }
18551
18552
18553 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18554 PyObject *pyobj = 0;
18555
18556 {
18557 #if wxUSE_UNICODE
18558 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18559 #else
18560 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18561 #endif
18562 }
18563 return pyobj;
18564 }
18565
18566
18567 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18568 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18569 return 1;
18570 }
18571
18572
18573 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18574 PyObject *pyobj = 0;
18575
18576 {
18577 #if wxUSE_UNICODE
18578 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18579 #else
18580 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18581 #endif
18582 }
18583 return pyobj;
18584 }
18585
18586
18587 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18588 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18589 return 1;
18590 }
18591
18592
18593 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18594 PyObject *pyobj = 0;
18595
18596 {
18597 #if wxUSE_UNICODE
18598 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18599 #else
18600 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18601 #endif
18602 }
18603 return pyobj;
18604 }
18605
18606
18607 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18608 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18609 return 1;
18610 }
18611
18612
18613 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18614 PyObject *pyobj = 0;
18615
18616 {
18617 #if wxUSE_UNICODE
18618 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18619 #else
18620 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18621 #endif
18622 }
18623 return pyobj;
18624 }
18625
18626
18627 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18628 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18629 return 1;
18630 }
18631
18632
18633 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18634 PyObject *pyobj = 0;
18635
18636 {
18637 #if wxUSE_UNICODE
18638 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18639 #else
18640 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18641 #endif
18642 }
18643 return pyobj;
18644 }
18645
18646
18647 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18648 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18649 return 1;
18650 }
18651
18652
18653 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18654 PyObject *pyobj = 0;
18655
18656 {
18657 #if wxUSE_UNICODE
18658 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18659 #else
18660 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18661 #endif
18662 }
18663 return pyobj;
18664 }
18665
18666
18667 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18668 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18669 return 1;
18670 }
18671
18672
18673 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18674 PyObject *pyobj = 0;
18675
18676 {
18677 #if wxUSE_UNICODE
18678 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18679 #else
18680 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18681 #endif
18682 }
18683 return pyobj;
18684 }
18685
18686
18687 SWIGINTERN int ART_PRINT_set(PyObject *) {
18688 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18689 return 1;
18690 }
18691
18692
18693 SWIGINTERN PyObject *ART_PRINT_get(void) {
18694 PyObject *pyobj = 0;
18695
18696 {
18697 #if wxUSE_UNICODE
18698 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18699 #else
18700 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18701 #endif
18702 }
18703 return pyobj;
18704 }
18705
18706
18707 SWIGINTERN int ART_HELP_set(PyObject *) {
18708 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18709 return 1;
18710 }
18711
18712
18713 SWIGINTERN PyObject *ART_HELP_get(void) {
18714 PyObject *pyobj = 0;
18715
18716 {
18717 #if wxUSE_UNICODE
18718 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18719 #else
18720 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18721 #endif
18722 }
18723 return pyobj;
18724 }
18725
18726
18727 SWIGINTERN int ART_TIP_set(PyObject *) {
18728 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18729 return 1;
18730 }
18731
18732
18733 SWIGINTERN PyObject *ART_TIP_get(void) {
18734 PyObject *pyobj = 0;
18735
18736 {
18737 #if wxUSE_UNICODE
18738 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18739 #else
18740 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18741 #endif
18742 }
18743 return pyobj;
18744 }
18745
18746
18747 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18748 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18749 return 1;
18750 }
18751
18752
18753 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18754 PyObject *pyobj = 0;
18755
18756 {
18757 #if wxUSE_UNICODE
18758 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18759 #else
18760 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18761 #endif
18762 }
18763 return pyobj;
18764 }
18765
18766
18767 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18768 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18769 return 1;
18770 }
18771
18772
18773 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18774 PyObject *pyobj = 0;
18775
18776 {
18777 #if wxUSE_UNICODE
18778 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18779 #else
18780 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18781 #endif
18782 }
18783 return pyobj;
18784 }
18785
18786
18787 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18788 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18789 return 1;
18790 }
18791
18792
18793 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18794 PyObject *pyobj = 0;
18795
18796 {
18797 #if wxUSE_UNICODE
18798 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18799 #else
18800 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18801 #endif
18802 }
18803 return pyobj;
18804 }
18805
18806
18807 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18808 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18809 return 1;
18810 }
18811
18812
18813 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18814 PyObject *pyobj = 0;
18815
18816 {
18817 #if wxUSE_UNICODE
18818 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18819 #else
18820 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18821 #endif
18822 }
18823 return pyobj;
18824 }
18825
18826
18827 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18828 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18829 return 1;
18830 }
18831
18832
18833 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18834 PyObject *pyobj = 0;
18835
18836 {
18837 #if wxUSE_UNICODE
18838 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18839 #else
18840 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18841 #endif
18842 }
18843 return pyobj;
18844 }
18845
18846
18847 SWIGINTERN int ART_CDROM_set(PyObject *) {
18848 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18849 return 1;
18850 }
18851
18852
18853 SWIGINTERN PyObject *ART_CDROM_get(void) {
18854 PyObject *pyobj = 0;
18855
18856 {
18857 #if wxUSE_UNICODE
18858 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18859 #else
18860 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18861 #endif
18862 }
18863 return pyobj;
18864 }
18865
18866
18867 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18868 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18869 return 1;
18870 }
18871
18872
18873 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18874 PyObject *pyobj = 0;
18875
18876 {
18877 #if wxUSE_UNICODE
18878 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18879 #else
18880 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18881 #endif
18882 }
18883 return pyobj;
18884 }
18885
18886
18887 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18888 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18889 return 1;
18890 }
18891
18892
18893 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18894 PyObject *pyobj = 0;
18895
18896 {
18897 #if wxUSE_UNICODE
18898 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18899 #else
18900 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18901 #endif
18902 }
18903 return pyobj;
18904 }
18905
18906
18907 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18908 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18909 return 1;
18910 }
18911
18912
18913 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18914 PyObject *pyobj = 0;
18915
18916 {
18917 #if wxUSE_UNICODE
18918 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18919 #else
18920 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18921 #endif
18922 }
18923 return pyobj;
18924 }
18925
18926
18927 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18928 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18929 return 1;
18930 }
18931
18932
18933 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18934 PyObject *pyobj = 0;
18935
18936 {
18937 #if wxUSE_UNICODE
18938 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18939 #else
18940 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18941 #endif
18942 }
18943 return pyobj;
18944 }
18945
18946
18947 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18948 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18949 return 1;
18950 }
18951
18952
18953 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18954 PyObject *pyobj = 0;
18955
18956 {
18957 #if wxUSE_UNICODE
18958 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18959 #else
18960 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18961 #endif
18962 }
18963 return pyobj;
18964 }
18965
18966
18967 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18968 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18969 return 1;
18970 }
18971
18972
18973 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18974 PyObject *pyobj = 0;
18975
18976 {
18977 #if wxUSE_UNICODE
18978 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18979 #else
18980 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18981 #endif
18982 }
18983 return pyobj;
18984 }
18985
18986
18987 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18988 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18989 return 1;
18990 }
18991
18992
18993 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18994 PyObject *pyobj = 0;
18995
18996 {
18997 #if wxUSE_UNICODE
18998 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18999 #else
19000 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19001 #endif
19002 }
19003 return pyobj;
19004 }
19005
19006
19007 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19008 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19009 return 1;
19010 }
19011
19012
19013 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19014 PyObject *pyobj = 0;
19015
19016 {
19017 #if wxUSE_UNICODE
19018 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19019 #else
19020 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19021 #endif
19022 }
19023 return pyobj;
19024 }
19025
19026
19027 SWIGINTERN int ART_ERROR_set(PyObject *) {
19028 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19029 return 1;
19030 }
19031
19032
19033 SWIGINTERN PyObject *ART_ERROR_get(void) {
19034 PyObject *pyobj = 0;
19035
19036 {
19037 #if wxUSE_UNICODE
19038 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19039 #else
19040 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19041 #endif
19042 }
19043 return pyobj;
19044 }
19045
19046
19047 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19048 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19049 return 1;
19050 }
19051
19052
19053 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19054 PyObject *pyobj = 0;
19055
19056 {
19057 #if wxUSE_UNICODE
19058 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19059 #else
19060 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19061 #endif
19062 }
19063 return pyobj;
19064 }
19065
19066
19067 SWIGINTERN int ART_WARNING_set(PyObject *) {
19068 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19069 return 1;
19070 }
19071
19072
19073 SWIGINTERN PyObject *ART_WARNING_get(void) {
19074 PyObject *pyobj = 0;
19075
19076 {
19077 #if wxUSE_UNICODE
19078 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19079 #else
19080 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19081 #endif
19082 }
19083 return pyobj;
19084 }
19085
19086
19087 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19088 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19089 return 1;
19090 }
19091
19092
19093 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19094 PyObject *pyobj = 0;
19095
19096 {
19097 #if wxUSE_UNICODE
19098 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19099 #else
19100 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19101 #endif
19102 }
19103 return pyobj;
19104 }
19105
19106
19107 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19108 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19109 return 1;
19110 }
19111
19112
19113 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19114 PyObject *pyobj = 0;
19115
19116 {
19117 #if wxUSE_UNICODE
19118 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19119 #else
19120 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19121 #endif
19122 }
19123 return pyobj;
19124 }
19125
19126
19127 SWIGINTERN int ART_COPY_set(PyObject *) {
19128 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
19129 return 1;
19130 }
19131
19132
19133 SWIGINTERN PyObject *ART_COPY_get(void) {
19134 PyObject *pyobj = 0;
19135
19136 {
19137 #if wxUSE_UNICODE
19138 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19139 #else
19140 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19141 #endif
19142 }
19143 return pyobj;
19144 }
19145
19146
19147 SWIGINTERN int ART_CUT_set(PyObject *) {
19148 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
19149 return 1;
19150 }
19151
19152
19153 SWIGINTERN PyObject *ART_CUT_get(void) {
19154 PyObject *pyobj = 0;
19155
19156 {
19157 #if wxUSE_UNICODE
19158 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19159 #else
19160 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19161 #endif
19162 }
19163 return pyobj;
19164 }
19165
19166
19167 SWIGINTERN int ART_PASTE_set(PyObject *) {
19168 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
19169 return 1;
19170 }
19171
19172
19173 SWIGINTERN PyObject *ART_PASTE_get(void) {
19174 PyObject *pyobj = 0;
19175
19176 {
19177 #if wxUSE_UNICODE
19178 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19179 #else
19180 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19181 #endif
19182 }
19183 return pyobj;
19184 }
19185
19186
19187 SWIGINTERN int ART_DELETE_set(PyObject *) {
19188 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19189 return 1;
19190 }
19191
19192
19193 SWIGINTERN PyObject *ART_DELETE_get(void) {
19194 PyObject *pyobj = 0;
19195
19196 {
19197 #if wxUSE_UNICODE
19198 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19199 #else
19200 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19201 #endif
19202 }
19203 return pyobj;
19204 }
19205
19206
19207 SWIGINTERN int ART_NEW_set(PyObject *) {
19208 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19209 return 1;
19210 }
19211
19212
19213 SWIGINTERN PyObject *ART_NEW_get(void) {
19214 PyObject *pyobj = 0;
19215
19216 {
19217 #if wxUSE_UNICODE
19218 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19219 #else
19220 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19221 #endif
19222 }
19223 return pyobj;
19224 }
19225
19226
19227 SWIGINTERN int ART_UNDO_set(PyObject *) {
19228 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19229 return 1;
19230 }
19231
19232
19233 SWIGINTERN PyObject *ART_UNDO_get(void) {
19234 PyObject *pyobj = 0;
19235
19236 {
19237 #if wxUSE_UNICODE
19238 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19239 #else
19240 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19241 #endif
19242 }
19243 return pyobj;
19244 }
19245
19246
19247 SWIGINTERN int ART_REDO_set(PyObject *) {
19248 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19249 return 1;
19250 }
19251
19252
19253 SWIGINTERN PyObject *ART_REDO_get(void) {
19254 PyObject *pyobj = 0;
19255
19256 {
19257 #if wxUSE_UNICODE
19258 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19259 #else
19260 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19261 #endif
19262 }
19263 return pyobj;
19264 }
19265
19266
19267 SWIGINTERN int ART_QUIT_set(PyObject *) {
19268 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19269 return 1;
19270 }
19271
19272
19273 SWIGINTERN PyObject *ART_QUIT_get(void) {
19274 PyObject *pyobj = 0;
19275
19276 {
19277 #if wxUSE_UNICODE
19278 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19279 #else
19280 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19281 #endif
19282 }
19283 return pyobj;
19284 }
19285
19286
19287 SWIGINTERN int ART_FIND_set(PyObject *) {
19288 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19289 return 1;
19290 }
19291
19292
19293 SWIGINTERN PyObject *ART_FIND_get(void) {
19294 PyObject *pyobj = 0;
19295
19296 {
19297 #if wxUSE_UNICODE
19298 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19299 #else
19300 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19301 #endif
19302 }
19303 return pyobj;
19304 }
19305
19306
19307 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19308 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19309 return 1;
19310 }
19311
19312
19313 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19314 PyObject *pyobj = 0;
19315
19316 {
19317 #if wxUSE_UNICODE
19318 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19319 #else
19320 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19321 #endif
19322 }
19323 return pyobj;
19324 }
19325
19326
19327 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19328 PyObject *resultobj = 0;
19329 wxPyArtProvider *result = 0 ;
19330
19331 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19332 {
19333 if (!wxPyCheckForApp()) SWIG_fail;
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 result = (wxPyArtProvider *)new wxPyArtProvider();
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19340 return resultobj;
19341 fail:
19342 return NULL;
19343 }
19344
19345
19346 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19347 PyObject *resultobj = 0;
19348 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19349 void *argp1 = 0 ;
19350 int res1 = 0 ;
19351 PyObject *swig_obj[1] ;
19352
19353 if (!args) SWIG_fail;
19354 swig_obj[0] = args;
19355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19356 if (!SWIG_IsOK(res1)) {
19357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19358 }
19359 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19360 {
19361 PyThreadState* __tstate = wxPyBeginAllowThreads();
19362 delete arg1;
19363
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_Py_Void();
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj = 0;
19376 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19377 PyObject *arg2 = (PyObject *) 0 ;
19378 PyObject *arg3 = (PyObject *) 0 ;
19379 void *argp1 = 0 ;
19380 int res1 = 0 ;
19381 PyObject * obj0 = 0 ;
19382 PyObject * obj1 = 0 ;
19383 PyObject * obj2 = 0 ;
19384 char * kwnames[] = {
19385 (char *) "self",(char *) "self",(char *) "_class", NULL
19386 };
19387
19388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19390 if (!SWIG_IsOK(res1)) {
19391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19392 }
19393 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19394 arg2 = obj1;
19395 arg3 = obj2;
19396 {
19397 PyThreadState* __tstate = wxPyBeginAllowThreads();
19398 (arg1)->_setCallbackInfo(arg2,arg3);
19399 wxPyEndAllowThreads(__tstate);
19400 if (PyErr_Occurred()) SWIG_fail;
19401 }
19402 resultobj = SWIG_Py_Void();
19403 return resultobj;
19404 fail:
19405 return NULL;
19406 }
19407
19408
19409 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19410 PyObject *resultobj = 0;
19411 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19412 int res1 = 0 ;
19413 PyObject * obj0 = 0 ;
19414 char * kwnames[] = {
19415 (char *) "provider", NULL
19416 };
19417
19418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19419 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19420 if (!SWIG_IsOK(res1)) {
19421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19422 }
19423 {
19424 PyThreadState* __tstate = wxPyBeginAllowThreads();
19425 wxPyArtProvider::PushProvider(arg1);
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 resultobj = SWIG_Py_Void();
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19437 PyObject *resultobj = 0;
19438 bool result;
19439
19440 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (bool)wxPyArtProvider::PopProvider();
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 {
19448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19449 }
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19457 PyObject *resultobj = 0;
19458 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19459 bool result;
19460 void *argp1 = 0 ;
19461 int res1 = 0 ;
19462 PyObject * obj0 = 0 ;
19463 char * kwnames[] = {
19464 (char *) "provider", NULL
19465 };
19466
19467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19469 if (!SWIG_IsOK(res1)) {
19470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19471 }
19472 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19473 {
19474 PyThreadState* __tstate = wxPyBeginAllowThreads();
19475 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 {
19480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19481 }
19482 return resultobj;
19483 fail:
19484 return NULL;
19485 }
19486
19487
19488 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19489 PyObject *resultobj = 0;
19490 wxString *arg1 = 0 ;
19491 wxString const &arg2_defvalue = wxPyART_OTHER ;
19492 wxString *arg2 = (wxString *) &arg2_defvalue ;
19493 wxSize const &arg3_defvalue = wxDefaultSize ;
19494 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19495 wxBitmap result;
19496 bool temp1 = false ;
19497 bool temp2 = false ;
19498 wxSize temp3 ;
19499 PyObject * obj0 = 0 ;
19500 PyObject * obj1 = 0 ;
19501 PyObject * obj2 = 0 ;
19502 char * kwnames[] = {
19503 (char *) "id",(char *) "client",(char *) "size", NULL
19504 };
19505
19506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19507 {
19508 arg1 = wxString_in_helper(obj0);
19509 if (arg1 == NULL) SWIG_fail;
19510 temp1 = true;
19511 }
19512 if (obj1) {
19513 {
19514 arg2 = wxString_in_helper(obj1);
19515 if (arg2 == NULL) SWIG_fail;
19516 temp2 = true;
19517 }
19518 }
19519 if (obj2) {
19520 {
19521 arg3 = &temp3;
19522 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19523 }
19524 }
19525 {
19526 if (!wxPyCheckForApp()) SWIG_fail;
19527 PyThreadState* __tstate = wxPyBeginAllowThreads();
19528 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19529 wxPyEndAllowThreads(__tstate);
19530 if (PyErr_Occurred()) SWIG_fail;
19531 }
19532 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19533 {
19534 if (temp1)
19535 delete arg1;
19536 }
19537 {
19538 if (temp2)
19539 delete arg2;
19540 }
19541 return resultobj;
19542 fail:
19543 {
19544 if (temp1)
19545 delete arg1;
19546 }
19547 {
19548 if (temp2)
19549 delete arg2;
19550 }
19551 return NULL;
19552 }
19553
19554
19555 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj = 0;
19557 wxString *arg1 = 0 ;
19558 wxString const &arg2_defvalue = wxPyART_OTHER ;
19559 wxString *arg2 = (wxString *) &arg2_defvalue ;
19560 wxSize const &arg3_defvalue = wxDefaultSize ;
19561 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19562 wxIcon result;
19563 bool temp1 = false ;
19564 bool temp2 = false ;
19565 wxSize temp3 ;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 PyObject * obj2 = 0 ;
19569 char * kwnames[] = {
19570 (char *) "id",(char *) "client",(char *) "size", NULL
19571 };
19572
19573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19574 {
19575 arg1 = wxString_in_helper(obj0);
19576 if (arg1 == NULL) SWIG_fail;
19577 temp1 = true;
19578 }
19579 if (obj1) {
19580 {
19581 arg2 = wxString_in_helper(obj1);
19582 if (arg2 == NULL) SWIG_fail;
19583 temp2 = true;
19584 }
19585 }
19586 if (obj2) {
19587 {
19588 arg3 = &temp3;
19589 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19590 }
19591 }
19592 {
19593 if (!wxPyCheckForApp()) SWIG_fail;
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19596 wxPyEndAllowThreads(__tstate);
19597 if (PyErr_Occurred()) SWIG_fail;
19598 }
19599 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19600 {
19601 if (temp1)
19602 delete arg1;
19603 }
19604 {
19605 if (temp2)
19606 delete arg2;
19607 }
19608 return resultobj;
19609 fail:
19610 {
19611 if (temp1)
19612 delete arg1;
19613 }
19614 {
19615 if (temp2)
19616 delete arg2;
19617 }
19618 return NULL;
19619 }
19620
19621
19622 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19623 PyObject *resultobj = 0;
19624 wxString *arg1 = 0 ;
19625 bool arg2 = (bool) false ;
19626 wxSize result;
19627 bool temp1 = false ;
19628 bool val2 ;
19629 int ecode2 = 0 ;
19630 PyObject * obj0 = 0 ;
19631 PyObject * obj1 = 0 ;
19632 char * kwnames[] = {
19633 (char *) "client",(char *) "platform_dependent", NULL
19634 };
19635
19636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19637 {
19638 arg1 = wxString_in_helper(obj0);
19639 if (arg1 == NULL) SWIG_fail;
19640 temp1 = true;
19641 }
19642 if (obj1) {
19643 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19644 if (!SWIG_IsOK(ecode2)) {
19645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19646 }
19647 arg2 = static_cast< bool >(val2);
19648 }
19649 {
19650 PyThreadState* __tstate = wxPyBeginAllowThreads();
19651 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19656 {
19657 if (temp1)
19658 delete arg1;
19659 }
19660 return resultobj;
19661 fail:
19662 {
19663 if (temp1)
19664 delete arg1;
19665 }
19666 return NULL;
19667 }
19668
19669
19670 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19671 PyObject *resultobj = 0;
19672 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19673 void *argp1 = 0 ;
19674 int res1 = 0 ;
19675 PyObject *swig_obj[1] ;
19676
19677 if (!args) SWIG_fail;
19678 swig_obj[0] = args;
19679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19680 if (!SWIG_IsOK(res1)) {
19681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19682 }
19683 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19684 {
19685 PyThreadState* __tstate = wxPyBeginAllowThreads();
19686 wxPyArtProvider_Destroy(arg1);
19687 wxPyEndAllowThreads(__tstate);
19688 if (PyErr_Occurred()) SWIG_fail;
19689 }
19690 resultobj = SWIG_Py_Void();
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19698 PyObject *obj;
19699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19700 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19701 return SWIG_Py_Void();
19702 }
19703
19704 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19705 return SWIG_Python_InitShadowInstance(args);
19706 }
19707
19708 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19709 PyObject *resultobj = 0;
19710 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19711 void *argp1 = 0 ;
19712 int res1 = 0 ;
19713 PyObject *swig_obj[1] ;
19714
19715 if (!args) SWIG_fail;
19716 swig_obj[0] = args;
19717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19718 if (!SWIG_IsOK(res1)) {
19719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19720 }
19721 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19722 {
19723 PyThreadState* __tstate = wxPyBeginAllowThreads();
19724 delete arg1;
19725
19726 wxPyEndAllowThreads(__tstate);
19727 if (PyErr_Occurred()) SWIG_fail;
19728 }
19729 resultobj = SWIG_Py_Void();
19730 return resultobj;
19731 fail:
19732 return NULL;
19733 }
19734
19735
19736 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj = 0;
19738 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19739 wxConfigBase *result = 0 ;
19740 int res1 = 0 ;
19741 PyObject * obj0 = 0 ;
19742 char * kwnames[] = {
19743 (char *) "config", NULL
19744 };
19745
19746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19747 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19748 if (!SWIG_IsOK(res1)) {
19749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19750 }
19751 {
19752 PyThreadState* __tstate = wxPyBeginAllowThreads();
19753 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19754 wxPyEndAllowThreads(__tstate);
19755 if (PyErr_Occurred()) SWIG_fail;
19756 }
19757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19758 return resultobj;
19759 fail:
19760 return NULL;
19761 }
19762
19763
19764 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19765 PyObject *resultobj = 0;
19766 bool arg1 = (bool) true ;
19767 wxConfigBase *result = 0 ;
19768 bool val1 ;
19769 int ecode1 = 0 ;
19770 PyObject * obj0 = 0 ;
19771 char * kwnames[] = {
19772 (char *) "createOnDemand", NULL
19773 };
19774
19775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19776 if (obj0) {
19777 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19778 if (!SWIG_IsOK(ecode1)) {
19779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19780 }
19781 arg1 = static_cast< bool >(val1);
19782 }
19783 {
19784 PyThreadState* __tstate = wxPyBeginAllowThreads();
19785 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19790 return resultobj;
19791 fail:
19792 return NULL;
19793 }
19794
19795
19796 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19797 PyObject *resultobj = 0;
19798 wxConfigBase *result = 0 ;
19799
19800 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19801 {
19802 PyThreadState* __tstate = wxPyBeginAllowThreads();
19803 result = (wxConfigBase *)wxConfigBase::Create();
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19815 PyObject *resultobj = 0;
19816
19817 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19818 {
19819 PyThreadState* __tstate = wxPyBeginAllowThreads();
19820 wxConfigBase::DontCreateOnDemand();
19821 wxPyEndAllowThreads(__tstate);
19822 if (PyErr_Occurred()) SWIG_fail;
19823 }
19824 resultobj = SWIG_Py_Void();
19825 return resultobj;
19826 fail:
19827 return NULL;
19828 }
19829
19830
19831 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19832 PyObject *resultobj = 0;
19833 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19834 wxString *arg2 = 0 ;
19835 void *argp1 = 0 ;
19836 int res1 = 0 ;
19837 bool temp2 = false ;
19838 PyObject * obj0 = 0 ;
19839 PyObject * obj1 = 0 ;
19840 char * kwnames[] = {
19841 (char *) "self",(char *) "path", NULL
19842 };
19843
19844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19846 if (!SWIG_IsOK(res1)) {
19847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19848 }
19849 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19850 {
19851 arg2 = wxString_in_helper(obj1);
19852 if (arg2 == NULL) SWIG_fail;
19853 temp2 = true;
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 (arg1)->SetPath((wxString const &)*arg2);
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 resultobj = SWIG_Py_Void();
19862 {
19863 if (temp2)
19864 delete arg2;
19865 }
19866 return resultobj;
19867 fail:
19868 {
19869 if (temp2)
19870 delete arg2;
19871 }
19872 return NULL;
19873 }
19874
19875
19876 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19877 PyObject *resultobj = 0;
19878 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19879 wxString *result = 0 ;
19880 void *argp1 = 0 ;
19881 int res1 = 0 ;
19882 PyObject *swig_obj[1] ;
19883
19884 if (!args) SWIG_fail;
19885 swig_obj[0] = args;
19886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19887 if (!SWIG_IsOK(res1)) {
19888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19889 }
19890 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 {
19894 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19895 result = (wxString *) &_result_ref;
19896 }
19897 wxPyEndAllowThreads(__tstate);
19898 if (PyErr_Occurred()) SWIG_fail;
19899 }
19900 {
19901 #if wxUSE_UNICODE
19902 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19903 #else
19904 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19905 #endif
19906 }
19907 return resultobj;
19908 fail:
19909 return NULL;
19910 }
19911
19912
19913 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19914 PyObject *resultobj = 0;
19915 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19916 PyObject *result = 0 ;
19917 void *argp1 = 0 ;
19918 int res1 = 0 ;
19919 PyObject *swig_obj[1] ;
19920
19921 if (!args) SWIG_fail;
19922 swig_obj[0] = args;
19923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19924 if (!SWIG_IsOK(res1)) {
19925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19926 }
19927 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19928 {
19929 PyThreadState* __tstate = wxPyBeginAllowThreads();
19930 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19931 wxPyEndAllowThreads(__tstate);
19932 if (PyErr_Occurred()) SWIG_fail;
19933 }
19934 resultobj = result;
19935 return resultobj;
19936 fail:
19937 return NULL;
19938 }
19939
19940
19941 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19942 PyObject *resultobj = 0;
19943 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19944 long arg2 ;
19945 PyObject *result = 0 ;
19946 void *argp1 = 0 ;
19947 int res1 = 0 ;
19948 long val2 ;
19949 int ecode2 = 0 ;
19950 PyObject * obj0 = 0 ;
19951 PyObject * obj1 = 0 ;
19952 char * kwnames[] = {
19953 (char *) "self",(char *) "index", NULL
19954 };
19955
19956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19958 if (!SWIG_IsOK(res1)) {
19959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19960 }
19961 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19962 ecode2 = SWIG_AsVal_long(obj1, &val2);
19963 if (!SWIG_IsOK(ecode2)) {
19964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19965 }
19966 arg2 = static_cast< long >(val2);
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19970 wxPyEndAllowThreads(__tstate);
19971 if (PyErr_Occurred()) SWIG_fail;
19972 }
19973 resultobj = result;
19974 return resultobj;
19975 fail:
19976 return NULL;
19977 }
19978
19979
19980 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19981 PyObject *resultobj = 0;
19982 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19983 PyObject *result = 0 ;
19984 void *argp1 = 0 ;
19985 int res1 = 0 ;
19986 PyObject *swig_obj[1] ;
19987
19988 if (!args) SWIG_fail;
19989 swig_obj[0] = args;
19990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19991 if (!SWIG_IsOK(res1)) {
19992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19993 }
19994 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19995 {
19996 PyThreadState* __tstate = wxPyBeginAllowThreads();
19997 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19998 wxPyEndAllowThreads(__tstate);
19999 if (PyErr_Occurred()) SWIG_fail;
20000 }
20001 resultobj = result;
20002 return resultobj;
20003 fail:
20004 return NULL;
20005 }
20006
20007
20008 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20009 PyObject *resultobj = 0;
20010 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20011 long arg2 ;
20012 PyObject *result = 0 ;
20013 void *argp1 = 0 ;
20014 int res1 = 0 ;
20015 long val2 ;
20016 int ecode2 = 0 ;
20017 PyObject * obj0 = 0 ;
20018 PyObject * obj1 = 0 ;
20019 char * kwnames[] = {
20020 (char *) "self",(char *) "index", NULL
20021 };
20022
20023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20025 if (!SWIG_IsOK(res1)) {
20026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20027 }
20028 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20029 ecode2 = SWIG_AsVal_long(obj1, &val2);
20030 if (!SWIG_IsOK(ecode2)) {
20031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20032 }
20033 arg2 = static_cast< long >(val2);
20034 {
20035 PyThreadState* __tstate = wxPyBeginAllowThreads();
20036 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20037 wxPyEndAllowThreads(__tstate);
20038 if (PyErr_Occurred()) SWIG_fail;
20039 }
20040 resultobj = result;
20041 return resultobj;
20042 fail:
20043 return NULL;
20044 }
20045
20046
20047 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20048 PyObject *resultobj = 0;
20049 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20050 bool arg2 = (bool) false ;
20051 size_t result;
20052 void *argp1 = 0 ;
20053 int res1 = 0 ;
20054 bool val2 ;
20055 int ecode2 = 0 ;
20056 PyObject * obj0 = 0 ;
20057 PyObject * obj1 = 0 ;
20058 char * kwnames[] = {
20059 (char *) "self",(char *) "recursive", NULL
20060 };
20061
20062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20064 if (!SWIG_IsOK(res1)) {
20065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20066 }
20067 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20068 if (obj1) {
20069 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20070 if (!SWIG_IsOK(ecode2)) {
20071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20072 }
20073 arg2 = static_cast< bool >(val2);
20074 }
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20078 wxPyEndAllowThreads(__tstate);
20079 if (PyErr_Occurred()) SWIG_fail;
20080 }
20081 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20082 return resultobj;
20083 fail:
20084 return NULL;
20085 }
20086
20087
20088 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20089 PyObject *resultobj = 0;
20090 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20091 bool arg2 = (bool) false ;
20092 size_t result;
20093 void *argp1 = 0 ;
20094 int res1 = 0 ;
20095 bool val2 ;
20096 int ecode2 = 0 ;
20097 PyObject * obj0 = 0 ;
20098 PyObject * obj1 = 0 ;
20099 char * kwnames[] = {
20100 (char *) "self",(char *) "recursive", NULL
20101 };
20102
20103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20105 if (!SWIG_IsOK(res1)) {
20106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20107 }
20108 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20109 if (obj1) {
20110 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20111 if (!SWIG_IsOK(ecode2)) {
20112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
20113 }
20114 arg2 = static_cast< bool >(val2);
20115 }
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20123 return resultobj;
20124 fail:
20125 return NULL;
20126 }
20127
20128
20129 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20130 PyObject *resultobj = 0;
20131 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20132 wxString *arg2 = 0 ;
20133 bool result;
20134 void *argp1 = 0 ;
20135 int res1 = 0 ;
20136 bool temp2 = false ;
20137 PyObject * obj0 = 0 ;
20138 PyObject * obj1 = 0 ;
20139 char * kwnames[] = {
20140 (char *) "self",(char *) "name", NULL
20141 };
20142
20143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20145 if (!SWIG_IsOK(res1)) {
20146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20147 }
20148 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20149 {
20150 arg2 = wxString_in_helper(obj1);
20151 if (arg2 == NULL) SWIG_fail;
20152 temp2 = true;
20153 }
20154 {
20155 PyThreadState* __tstate = wxPyBeginAllowThreads();
20156 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
20157 wxPyEndAllowThreads(__tstate);
20158 if (PyErr_Occurred()) SWIG_fail;
20159 }
20160 {
20161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20162 }
20163 {
20164 if (temp2)
20165 delete arg2;
20166 }
20167 return resultobj;
20168 fail:
20169 {
20170 if (temp2)
20171 delete arg2;
20172 }
20173 return NULL;
20174 }
20175
20176
20177 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20178 PyObject *resultobj = 0;
20179 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20180 wxString *arg2 = 0 ;
20181 bool result;
20182 void *argp1 = 0 ;
20183 int res1 = 0 ;
20184 bool temp2 = false ;
20185 PyObject * obj0 = 0 ;
20186 PyObject * obj1 = 0 ;
20187 char * kwnames[] = {
20188 (char *) "self",(char *) "name", NULL
20189 };
20190
20191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20193 if (!SWIG_IsOK(res1)) {
20194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20195 }
20196 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20197 {
20198 arg2 = wxString_in_helper(obj1);
20199 if (arg2 == NULL) SWIG_fail;
20200 temp2 = true;
20201 }
20202 {
20203 PyThreadState* __tstate = wxPyBeginAllowThreads();
20204 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20205 wxPyEndAllowThreads(__tstate);
20206 if (PyErr_Occurred()) SWIG_fail;
20207 }
20208 {
20209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20210 }
20211 {
20212 if (temp2)
20213 delete arg2;
20214 }
20215 return resultobj;
20216 fail:
20217 {
20218 if (temp2)
20219 delete arg2;
20220 }
20221 return NULL;
20222 }
20223
20224
20225 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20226 PyObject *resultobj = 0;
20227 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20228 wxString *arg2 = 0 ;
20229 bool result;
20230 void *argp1 = 0 ;
20231 int res1 = 0 ;
20232 bool temp2 = false ;
20233 PyObject * obj0 = 0 ;
20234 PyObject * obj1 = 0 ;
20235 char * kwnames[] = {
20236 (char *) "self",(char *) "name", NULL
20237 };
20238
20239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20241 if (!SWIG_IsOK(res1)) {
20242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20243 }
20244 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20245 {
20246 arg2 = wxString_in_helper(obj1);
20247 if (arg2 == NULL) SWIG_fail;
20248 temp2 = true;
20249 }
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 {
20257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20258 }
20259 {
20260 if (temp2)
20261 delete arg2;
20262 }
20263 return resultobj;
20264 fail:
20265 {
20266 if (temp2)
20267 delete arg2;
20268 }
20269 return NULL;
20270 }
20271
20272
20273 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20274 PyObject *resultobj = 0;
20275 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20276 wxString *arg2 = 0 ;
20277 wxConfigBase::EntryType result;
20278 void *argp1 = 0 ;
20279 int res1 = 0 ;
20280 bool temp2 = false ;
20281 PyObject * obj0 = 0 ;
20282 PyObject * obj1 = 0 ;
20283 char * kwnames[] = {
20284 (char *) "self",(char *) "name", NULL
20285 };
20286
20287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20289 if (!SWIG_IsOK(res1)) {
20290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20291 }
20292 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20293 {
20294 arg2 = wxString_in_helper(obj1);
20295 if (arg2 == NULL) SWIG_fail;
20296 temp2 = true;
20297 }
20298 {
20299 PyThreadState* __tstate = wxPyBeginAllowThreads();
20300 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20301 wxPyEndAllowThreads(__tstate);
20302 if (PyErr_Occurred()) SWIG_fail;
20303 }
20304 resultobj = SWIG_From_int(static_cast< int >(result));
20305 {
20306 if (temp2)
20307 delete arg2;
20308 }
20309 return resultobj;
20310 fail:
20311 {
20312 if (temp2)
20313 delete arg2;
20314 }
20315 return NULL;
20316 }
20317
20318
20319 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20320 PyObject *resultobj = 0;
20321 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20322 wxString *arg2 = 0 ;
20323 wxString const &arg3_defvalue = wxPyEmptyString ;
20324 wxString *arg3 = (wxString *) &arg3_defvalue ;
20325 wxString result;
20326 void *argp1 = 0 ;
20327 int res1 = 0 ;
20328 bool temp2 = false ;
20329 bool temp3 = false ;
20330 PyObject * obj0 = 0 ;
20331 PyObject * obj1 = 0 ;
20332 PyObject * obj2 = 0 ;
20333 char * kwnames[] = {
20334 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20335 };
20336
20337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20339 if (!SWIG_IsOK(res1)) {
20340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20341 }
20342 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20343 {
20344 arg2 = wxString_in_helper(obj1);
20345 if (arg2 == NULL) SWIG_fail;
20346 temp2 = true;
20347 }
20348 if (obj2) {
20349 {
20350 arg3 = wxString_in_helper(obj2);
20351 if (arg3 == NULL) SWIG_fail;
20352 temp3 = true;
20353 }
20354 }
20355 {
20356 PyThreadState* __tstate = wxPyBeginAllowThreads();
20357 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20358 wxPyEndAllowThreads(__tstate);
20359 if (PyErr_Occurred()) SWIG_fail;
20360 }
20361 {
20362 #if wxUSE_UNICODE
20363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20364 #else
20365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20366 #endif
20367 }
20368 {
20369 if (temp2)
20370 delete arg2;
20371 }
20372 {
20373 if (temp3)
20374 delete arg3;
20375 }
20376 return resultobj;
20377 fail:
20378 {
20379 if (temp2)
20380 delete arg2;
20381 }
20382 {
20383 if (temp3)
20384 delete arg3;
20385 }
20386 return NULL;
20387 }
20388
20389
20390 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20391 PyObject *resultobj = 0;
20392 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20393 wxString *arg2 = 0 ;
20394 long arg3 = (long) 0 ;
20395 long result;
20396 void *argp1 = 0 ;
20397 int res1 = 0 ;
20398 bool temp2 = false ;
20399 long val3 ;
20400 int ecode3 = 0 ;
20401 PyObject * obj0 = 0 ;
20402 PyObject * obj1 = 0 ;
20403 PyObject * obj2 = 0 ;
20404 char * kwnames[] = {
20405 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20406 };
20407
20408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20410 if (!SWIG_IsOK(res1)) {
20411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20412 }
20413 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20414 {
20415 arg2 = wxString_in_helper(obj1);
20416 if (arg2 == NULL) SWIG_fail;
20417 temp2 = true;
20418 }
20419 if (obj2) {
20420 ecode3 = SWIG_AsVal_long(obj2, &val3);
20421 if (!SWIG_IsOK(ecode3)) {
20422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20423 }
20424 arg3 = static_cast< long >(val3);
20425 }
20426 {
20427 PyThreadState* __tstate = wxPyBeginAllowThreads();
20428 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20429 wxPyEndAllowThreads(__tstate);
20430 if (PyErr_Occurred()) SWIG_fail;
20431 }
20432 resultobj = SWIG_From_long(static_cast< long >(result));
20433 {
20434 if (temp2)
20435 delete arg2;
20436 }
20437 return resultobj;
20438 fail:
20439 {
20440 if (temp2)
20441 delete arg2;
20442 }
20443 return NULL;
20444 }
20445
20446
20447 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20448 PyObject *resultobj = 0;
20449 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20450 wxString *arg2 = 0 ;
20451 double arg3 = (double) 0.0 ;
20452 double result;
20453 void *argp1 = 0 ;
20454 int res1 = 0 ;
20455 bool temp2 = false ;
20456 double val3 ;
20457 int ecode3 = 0 ;
20458 PyObject * obj0 = 0 ;
20459 PyObject * obj1 = 0 ;
20460 PyObject * obj2 = 0 ;
20461 char * kwnames[] = {
20462 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20463 };
20464
20465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20467 if (!SWIG_IsOK(res1)) {
20468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20469 }
20470 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20471 {
20472 arg2 = wxString_in_helper(obj1);
20473 if (arg2 == NULL) SWIG_fail;
20474 temp2 = true;
20475 }
20476 if (obj2) {
20477 ecode3 = SWIG_AsVal_double(obj2, &val3);
20478 if (!SWIG_IsOK(ecode3)) {
20479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20480 }
20481 arg3 = static_cast< double >(val3);
20482 }
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20486 wxPyEndAllowThreads(__tstate);
20487 if (PyErr_Occurred()) SWIG_fail;
20488 }
20489 resultobj = SWIG_From_double(static_cast< double >(result));
20490 {
20491 if (temp2)
20492 delete arg2;
20493 }
20494 return resultobj;
20495 fail:
20496 {
20497 if (temp2)
20498 delete arg2;
20499 }
20500 return NULL;
20501 }
20502
20503
20504 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20505 PyObject *resultobj = 0;
20506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20507 wxString *arg2 = 0 ;
20508 bool arg3 = (bool) false ;
20509 bool result;
20510 void *argp1 = 0 ;
20511 int res1 = 0 ;
20512 bool temp2 = false ;
20513 bool val3 ;
20514 int ecode3 = 0 ;
20515 PyObject * obj0 = 0 ;
20516 PyObject * obj1 = 0 ;
20517 PyObject * obj2 = 0 ;
20518 char * kwnames[] = {
20519 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20520 };
20521
20522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20524 if (!SWIG_IsOK(res1)) {
20525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20526 }
20527 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20528 {
20529 arg2 = wxString_in_helper(obj1);
20530 if (arg2 == NULL) SWIG_fail;
20531 temp2 = true;
20532 }
20533 if (obj2) {
20534 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20535 if (!SWIG_IsOK(ecode3)) {
20536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20537 }
20538 arg3 = static_cast< bool >(val3);
20539 }
20540 {
20541 PyThreadState* __tstate = wxPyBeginAllowThreads();
20542 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20543 wxPyEndAllowThreads(__tstate);
20544 if (PyErr_Occurred()) SWIG_fail;
20545 }
20546 {
20547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20548 }
20549 {
20550 if (temp2)
20551 delete arg2;
20552 }
20553 return resultobj;
20554 fail:
20555 {
20556 if (temp2)
20557 delete arg2;
20558 }
20559 return NULL;
20560 }
20561
20562
20563 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20564 PyObject *resultobj = 0;
20565 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20566 wxString *arg2 = 0 ;
20567 wxString *arg3 = 0 ;
20568 bool result;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 bool temp2 = false ;
20572 bool temp3 = false ;
20573 PyObject * obj0 = 0 ;
20574 PyObject * obj1 = 0 ;
20575 PyObject * obj2 = 0 ;
20576 char * kwnames[] = {
20577 (char *) "self",(char *) "key",(char *) "value", NULL
20578 };
20579
20580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20582 if (!SWIG_IsOK(res1)) {
20583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20584 }
20585 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20586 {
20587 arg2 = wxString_in_helper(obj1);
20588 if (arg2 == NULL) SWIG_fail;
20589 temp2 = true;
20590 }
20591 {
20592 arg3 = wxString_in_helper(obj2);
20593 if (arg3 == NULL) SWIG_fail;
20594 temp3 = true;
20595 }
20596 {
20597 PyThreadState* __tstate = wxPyBeginAllowThreads();
20598 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 {
20603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20604 }
20605 {
20606 if (temp2)
20607 delete arg2;
20608 }
20609 {
20610 if (temp3)
20611 delete arg3;
20612 }
20613 return resultobj;
20614 fail:
20615 {
20616 if (temp2)
20617 delete arg2;
20618 }
20619 {
20620 if (temp3)
20621 delete arg3;
20622 }
20623 return NULL;
20624 }
20625
20626
20627 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20628 PyObject *resultobj = 0;
20629 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20630 wxString *arg2 = 0 ;
20631 long arg3 ;
20632 bool result;
20633 void *argp1 = 0 ;
20634 int res1 = 0 ;
20635 bool temp2 = false ;
20636 long val3 ;
20637 int ecode3 = 0 ;
20638 PyObject * obj0 = 0 ;
20639 PyObject * obj1 = 0 ;
20640 PyObject * obj2 = 0 ;
20641 char * kwnames[] = {
20642 (char *) "self",(char *) "key",(char *) "value", NULL
20643 };
20644
20645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20647 if (!SWIG_IsOK(res1)) {
20648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20649 }
20650 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20651 {
20652 arg2 = wxString_in_helper(obj1);
20653 if (arg2 == NULL) SWIG_fail;
20654 temp2 = true;
20655 }
20656 ecode3 = SWIG_AsVal_long(obj2, &val3);
20657 if (!SWIG_IsOK(ecode3)) {
20658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20659 }
20660 arg3 = static_cast< long >(val3);
20661 {
20662 PyThreadState* __tstate = wxPyBeginAllowThreads();
20663 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20664 wxPyEndAllowThreads(__tstate);
20665 if (PyErr_Occurred()) SWIG_fail;
20666 }
20667 {
20668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20669 }
20670 {
20671 if (temp2)
20672 delete arg2;
20673 }
20674 return resultobj;
20675 fail:
20676 {
20677 if (temp2)
20678 delete arg2;
20679 }
20680 return NULL;
20681 }
20682
20683
20684 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20685 PyObject *resultobj = 0;
20686 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20687 wxString *arg2 = 0 ;
20688 double arg3 ;
20689 bool result;
20690 void *argp1 = 0 ;
20691 int res1 = 0 ;
20692 bool temp2 = false ;
20693 double val3 ;
20694 int ecode3 = 0 ;
20695 PyObject * obj0 = 0 ;
20696 PyObject * obj1 = 0 ;
20697 PyObject * obj2 = 0 ;
20698 char * kwnames[] = {
20699 (char *) "self",(char *) "key",(char *) "value", NULL
20700 };
20701
20702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20704 if (!SWIG_IsOK(res1)) {
20705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20706 }
20707 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20708 {
20709 arg2 = wxString_in_helper(obj1);
20710 if (arg2 == NULL) SWIG_fail;
20711 temp2 = true;
20712 }
20713 ecode3 = SWIG_AsVal_double(obj2, &val3);
20714 if (!SWIG_IsOK(ecode3)) {
20715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20716 }
20717 arg3 = static_cast< double >(val3);
20718 {
20719 PyThreadState* __tstate = wxPyBeginAllowThreads();
20720 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20721 wxPyEndAllowThreads(__tstate);
20722 if (PyErr_Occurred()) SWIG_fail;
20723 }
20724 {
20725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20726 }
20727 {
20728 if (temp2)
20729 delete arg2;
20730 }
20731 return resultobj;
20732 fail:
20733 {
20734 if (temp2)
20735 delete arg2;
20736 }
20737 return NULL;
20738 }
20739
20740
20741 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20742 PyObject *resultobj = 0;
20743 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20744 wxString *arg2 = 0 ;
20745 bool arg3 ;
20746 bool result;
20747 void *argp1 = 0 ;
20748 int res1 = 0 ;
20749 bool temp2 = false ;
20750 bool val3 ;
20751 int ecode3 = 0 ;
20752 PyObject * obj0 = 0 ;
20753 PyObject * obj1 = 0 ;
20754 PyObject * obj2 = 0 ;
20755 char * kwnames[] = {
20756 (char *) "self",(char *) "key",(char *) "value", NULL
20757 };
20758
20759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20761 if (!SWIG_IsOK(res1)) {
20762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20763 }
20764 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20765 {
20766 arg2 = wxString_in_helper(obj1);
20767 if (arg2 == NULL) SWIG_fail;
20768 temp2 = true;
20769 }
20770 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20771 if (!SWIG_IsOK(ecode3)) {
20772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20773 }
20774 arg3 = static_cast< bool >(val3);
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20778 wxPyEndAllowThreads(__tstate);
20779 if (PyErr_Occurred()) SWIG_fail;
20780 }
20781 {
20782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20783 }
20784 {
20785 if (temp2)
20786 delete arg2;
20787 }
20788 return resultobj;
20789 fail:
20790 {
20791 if (temp2)
20792 delete arg2;
20793 }
20794 return NULL;
20795 }
20796
20797
20798 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj = 0;
20800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20801 bool arg2 = (bool) false ;
20802 bool result;
20803 void *argp1 = 0 ;
20804 int res1 = 0 ;
20805 bool val2 ;
20806 int ecode2 = 0 ;
20807 PyObject * obj0 = 0 ;
20808 PyObject * obj1 = 0 ;
20809 char * kwnames[] = {
20810 (char *) "self",(char *) "currentOnly", NULL
20811 };
20812
20813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20815 if (!SWIG_IsOK(res1)) {
20816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20817 }
20818 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20819 if (obj1) {
20820 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20821 if (!SWIG_IsOK(ecode2)) {
20822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20823 }
20824 arg2 = static_cast< bool >(val2);
20825 }
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 result = (bool)(arg1)->Flush(arg2);
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 {
20833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20834 }
20835 return resultobj;
20836 fail:
20837 return NULL;
20838 }
20839
20840
20841 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20842 PyObject *resultobj = 0;
20843 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20844 wxString *arg2 = 0 ;
20845 wxString *arg3 = 0 ;
20846 bool result;
20847 void *argp1 = 0 ;
20848 int res1 = 0 ;
20849 bool temp2 = false ;
20850 bool temp3 = false ;
20851 PyObject * obj0 = 0 ;
20852 PyObject * obj1 = 0 ;
20853 PyObject * obj2 = 0 ;
20854 char * kwnames[] = {
20855 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20856 };
20857
20858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20860 if (!SWIG_IsOK(res1)) {
20861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20862 }
20863 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20864 {
20865 arg2 = wxString_in_helper(obj1);
20866 if (arg2 == NULL) SWIG_fail;
20867 temp2 = true;
20868 }
20869 {
20870 arg3 = wxString_in_helper(obj2);
20871 if (arg3 == NULL) SWIG_fail;
20872 temp3 = true;
20873 }
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 {
20881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20882 }
20883 {
20884 if (temp2)
20885 delete arg2;
20886 }
20887 {
20888 if (temp3)
20889 delete arg3;
20890 }
20891 return resultobj;
20892 fail:
20893 {
20894 if (temp2)
20895 delete arg2;
20896 }
20897 {
20898 if (temp3)
20899 delete arg3;
20900 }
20901 return NULL;
20902 }
20903
20904
20905 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20906 PyObject *resultobj = 0;
20907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20908 wxString *arg2 = 0 ;
20909 wxString *arg3 = 0 ;
20910 bool result;
20911 void *argp1 = 0 ;
20912 int res1 = 0 ;
20913 bool temp2 = false ;
20914 bool temp3 = false ;
20915 PyObject * obj0 = 0 ;
20916 PyObject * obj1 = 0 ;
20917 PyObject * obj2 = 0 ;
20918 char * kwnames[] = {
20919 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20920 };
20921
20922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20924 if (!SWIG_IsOK(res1)) {
20925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20926 }
20927 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20928 {
20929 arg2 = wxString_in_helper(obj1);
20930 if (arg2 == NULL) SWIG_fail;
20931 temp2 = true;
20932 }
20933 {
20934 arg3 = wxString_in_helper(obj2);
20935 if (arg3 == NULL) SWIG_fail;
20936 temp3 = true;
20937 }
20938 {
20939 PyThreadState* __tstate = wxPyBeginAllowThreads();
20940 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 {
20945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20946 }
20947 {
20948 if (temp2)
20949 delete arg2;
20950 }
20951 {
20952 if (temp3)
20953 delete arg3;
20954 }
20955 return resultobj;
20956 fail:
20957 {
20958 if (temp2)
20959 delete arg2;
20960 }
20961 {
20962 if (temp3)
20963 delete arg3;
20964 }
20965 return NULL;
20966 }
20967
20968
20969 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20970 PyObject *resultobj = 0;
20971 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20972 wxString *arg2 = 0 ;
20973 bool arg3 = (bool) true ;
20974 bool result;
20975 void *argp1 = 0 ;
20976 int res1 = 0 ;
20977 bool temp2 = false ;
20978 bool val3 ;
20979 int ecode3 = 0 ;
20980 PyObject * obj0 = 0 ;
20981 PyObject * obj1 = 0 ;
20982 PyObject * obj2 = 0 ;
20983 char * kwnames[] = {
20984 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20985 };
20986
20987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20989 if (!SWIG_IsOK(res1)) {
20990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20991 }
20992 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20993 {
20994 arg2 = wxString_in_helper(obj1);
20995 if (arg2 == NULL) SWIG_fail;
20996 temp2 = true;
20997 }
20998 if (obj2) {
20999 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21000 if (!SWIG_IsOK(ecode3)) {
21001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
21002 }
21003 arg3 = static_cast< bool >(val3);
21004 }
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21008 wxPyEndAllowThreads(__tstate);
21009 if (PyErr_Occurred()) SWIG_fail;
21010 }
21011 {
21012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21013 }
21014 {
21015 if (temp2)
21016 delete arg2;
21017 }
21018 return resultobj;
21019 fail:
21020 {
21021 if (temp2)
21022 delete arg2;
21023 }
21024 return NULL;
21025 }
21026
21027
21028 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21029 PyObject *resultobj = 0;
21030 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21031 wxString *arg2 = 0 ;
21032 bool result;
21033 void *argp1 = 0 ;
21034 int res1 = 0 ;
21035 bool temp2 = false ;
21036 PyObject * obj0 = 0 ;
21037 PyObject * obj1 = 0 ;
21038 char * kwnames[] = {
21039 (char *) "self",(char *) "key", NULL
21040 };
21041
21042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21044 if (!SWIG_IsOK(res1)) {
21045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21046 }
21047 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21048 {
21049 arg2 = wxString_in_helper(obj1);
21050 if (arg2 == NULL) SWIG_fail;
21051 temp2 = true;
21052 }
21053 {
21054 PyThreadState* __tstate = wxPyBeginAllowThreads();
21055 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21056 wxPyEndAllowThreads(__tstate);
21057 if (PyErr_Occurred()) SWIG_fail;
21058 }
21059 {
21060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21061 }
21062 {
21063 if (temp2)
21064 delete arg2;
21065 }
21066 return resultobj;
21067 fail:
21068 {
21069 if (temp2)
21070 delete arg2;
21071 }
21072 return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21077 PyObject *resultobj = 0;
21078 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21079 bool result;
21080 void *argp1 = 0 ;
21081 int res1 = 0 ;
21082 PyObject *swig_obj[1] ;
21083
21084 if (!args) SWIG_fail;
21085 swig_obj[0] = args;
21086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21087 if (!SWIG_IsOK(res1)) {
21088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21089 }
21090 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21091 {
21092 PyThreadState* __tstate = wxPyBeginAllowThreads();
21093 result = (bool)(arg1)->DeleteAll();
21094 wxPyEndAllowThreads(__tstate);
21095 if (PyErr_Occurred()) SWIG_fail;
21096 }
21097 {
21098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21099 }
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21107 PyObject *resultobj = 0;
21108 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21109 bool arg2 = (bool) true ;
21110 void *argp1 = 0 ;
21111 int res1 = 0 ;
21112 bool val2 ;
21113 int ecode2 = 0 ;
21114 PyObject * obj0 = 0 ;
21115 PyObject * obj1 = 0 ;
21116 char * kwnames[] = {
21117 (char *) "self",(char *) "doIt", NULL
21118 };
21119
21120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21122 if (!SWIG_IsOK(res1)) {
21123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21124 }
21125 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21126 if (obj1) {
21127 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21128 if (!SWIG_IsOK(ecode2)) {
21129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
21130 }
21131 arg2 = static_cast< bool >(val2);
21132 }
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 (arg1)->SetExpandEnvVars(arg2);
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 resultobj = SWIG_Py_Void();
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21147 PyObject *resultobj = 0;
21148 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21149 bool result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 PyObject *swig_obj[1] ;
21153
21154 if (!args) SWIG_fail;
21155 swig_obj[0] = args;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21159 }
21160 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 {
21168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21169 }
21170 return resultobj;
21171 fail:
21172 return NULL;
21173 }
21174
21175
21176 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21177 PyObject *resultobj = 0;
21178 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21179 bool arg2 = (bool) true ;
21180 void *argp1 = 0 ;
21181 int res1 = 0 ;
21182 bool val2 ;
21183 int ecode2 = 0 ;
21184 PyObject * obj0 = 0 ;
21185 PyObject * obj1 = 0 ;
21186 char * kwnames[] = {
21187 (char *) "self",(char *) "doIt", NULL
21188 };
21189
21190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21192 if (!SWIG_IsOK(res1)) {
21193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21194 }
21195 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21196 if (obj1) {
21197 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21198 if (!SWIG_IsOK(ecode2)) {
21199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21200 }
21201 arg2 = static_cast< bool >(val2);
21202 }
21203 {
21204 PyThreadState* __tstate = wxPyBeginAllowThreads();
21205 (arg1)->SetRecordDefaults(arg2);
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 resultobj = SWIG_Py_Void();
21210 return resultobj;
21211 fail:
21212 return NULL;
21213 }
21214
21215
21216 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21217 PyObject *resultobj = 0;
21218 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21219 bool result;
21220 void *argp1 = 0 ;
21221 int res1 = 0 ;
21222 PyObject *swig_obj[1] ;
21223
21224 if (!args) SWIG_fail;
21225 swig_obj[0] = args;
21226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21227 if (!SWIG_IsOK(res1)) {
21228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21229 }
21230 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21231 {
21232 PyThreadState* __tstate = wxPyBeginAllowThreads();
21233 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21234 wxPyEndAllowThreads(__tstate);
21235 if (PyErr_Occurred()) SWIG_fail;
21236 }
21237 {
21238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21239 }
21240 return resultobj;
21241 fail:
21242 return NULL;
21243 }
21244
21245
21246 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21247 PyObject *resultobj = 0;
21248 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21249 wxString *arg2 = 0 ;
21250 wxString result;
21251 void *argp1 = 0 ;
21252 int res1 = 0 ;
21253 bool temp2 = false ;
21254 PyObject * obj0 = 0 ;
21255 PyObject * obj1 = 0 ;
21256 char * kwnames[] = {
21257 (char *) "self",(char *) "str", NULL
21258 };
21259
21260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21264 }
21265 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21266 {
21267 arg2 = wxString_in_helper(obj1);
21268 if (arg2 == NULL) SWIG_fail;
21269 temp2 = true;
21270 }
21271 {
21272 PyThreadState* __tstate = wxPyBeginAllowThreads();
21273 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21274 wxPyEndAllowThreads(__tstate);
21275 if (PyErr_Occurred()) SWIG_fail;
21276 }
21277 {
21278 #if wxUSE_UNICODE
21279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21280 #else
21281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21282 #endif
21283 }
21284 {
21285 if (temp2)
21286 delete arg2;
21287 }
21288 return resultobj;
21289 fail:
21290 {
21291 if (temp2)
21292 delete arg2;
21293 }
21294 return NULL;
21295 }
21296
21297
21298 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21299 PyObject *resultobj = 0;
21300 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21301 wxString result;
21302 void *argp1 = 0 ;
21303 int res1 = 0 ;
21304 PyObject *swig_obj[1] ;
21305
21306 if (!args) SWIG_fail;
21307 swig_obj[0] = args;
21308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21311 }
21312 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21313 {
21314 PyThreadState* __tstate = wxPyBeginAllowThreads();
21315 result = ((wxConfigBase const *)arg1)->GetAppName();
21316 wxPyEndAllowThreads(__tstate);
21317 if (PyErr_Occurred()) SWIG_fail;
21318 }
21319 {
21320 #if wxUSE_UNICODE
21321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21322 #else
21323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21324 #endif
21325 }
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21333 PyObject *resultobj = 0;
21334 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21335 wxString result;
21336 void *argp1 = 0 ;
21337 int res1 = 0 ;
21338 PyObject *swig_obj[1] ;
21339
21340 if (!args) SWIG_fail;
21341 swig_obj[0] = args;
21342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21343 if (!SWIG_IsOK(res1)) {
21344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21345 }
21346 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 result = ((wxConfigBase const *)arg1)->GetVendorName();
21350 wxPyEndAllowThreads(__tstate);
21351 if (PyErr_Occurred()) SWIG_fail;
21352 }
21353 {
21354 #if wxUSE_UNICODE
21355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21356 #else
21357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21358 #endif
21359 }
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21367 PyObject *resultobj = 0;
21368 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21369 wxString *arg2 = 0 ;
21370 void *argp1 = 0 ;
21371 int res1 = 0 ;
21372 bool temp2 = false ;
21373 PyObject * obj0 = 0 ;
21374 PyObject * obj1 = 0 ;
21375 char * kwnames[] = {
21376 (char *) "self",(char *) "appName", NULL
21377 };
21378
21379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21381 if (!SWIG_IsOK(res1)) {
21382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21383 }
21384 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21385 {
21386 arg2 = wxString_in_helper(obj1);
21387 if (arg2 == NULL) SWIG_fail;
21388 temp2 = true;
21389 }
21390 {
21391 PyThreadState* __tstate = wxPyBeginAllowThreads();
21392 (arg1)->SetAppName((wxString const &)*arg2);
21393 wxPyEndAllowThreads(__tstate);
21394 if (PyErr_Occurred()) SWIG_fail;
21395 }
21396 resultobj = SWIG_Py_Void();
21397 {
21398 if (temp2)
21399 delete arg2;
21400 }
21401 return resultobj;
21402 fail:
21403 {
21404 if (temp2)
21405 delete arg2;
21406 }
21407 return NULL;
21408 }
21409
21410
21411 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj = 0;
21413 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21414 wxString *arg2 = 0 ;
21415 void *argp1 = 0 ;
21416 int res1 = 0 ;
21417 bool temp2 = false ;
21418 PyObject * obj0 = 0 ;
21419 PyObject * obj1 = 0 ;
21420 char * kwnames[] = {
21421 (char *) "self",(char *) "vendorName", NULL
21422 };
21423
21424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21426 if (!SWIG_IsOK(res1)) {
21427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21428 }
21429 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21430 {
21431 arg2 = wxString_in_helper(obj1);
21432 if (arg2 == NULL) SWIG_fail;
21433 temp2 = true;
21434 }
21435 {
21436 PyThreadState* __tstate = wxPyBeginAllowThreads();
21437 (arg1)->SetVendorName((wxString const &)*arg2);
21438 wxPyEndAllowThreads(__tstate);
21439 if (PyErr_Occurred()) SWIG_fail;
21440 }
21441 resultobj = SWIG_Py_Void();
21442 {
21443 if (temp2)
21444 delete arg2;
21445 }
21446 return resultobj;
21447 fail:
21448 {
21449 if (temp2)
21450 delete arg2;
21451 }
21452 return NULL;
21453 }
21454
21455
21456 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21457 PyObject *resultobj = 0;
21458 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21459 long arg2 ;
21460 void *argp1 = 0 ;
21461 int res1 = 0 ;
21462 long val2 ;
21463 int ecode2 = 0 ;
21464 PyObject * obj0 = 0 ;
21465 PyObject * obj1 = 0 ;
21466 char * kwnames[] = {
21467 (char *) "self",(char *) "style", NULL
21468 };
21469
21470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21472 if (!SWIG_IsOK(res1)) {
21473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21474 }
21475 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21476 ecode2 = SWIG_AsVal_long(obj1, &val2);
21477 if (!SWIG_IsOK(ecode2)) {
21478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21479 }
21480 arg2 = static_cast< long >(val2);
21481 {
21482 PyThreadState* __tstate = wxPyBeginAllowThreads();
21483 (arg1)->SetStyle(arg2);
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 resultobj = SWIG_Py_Void();
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21495 PyObject *resultobj = 0;
21496 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21497 long result;
21498 void *argp1 = 0 ;
21499 int res1 = 0 ;
21500 PyObject *swig_obj[1] ;
21501
21502 if (!args) SWIG_fail;
21503 swig_obj[0] = args;
21504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21505 if (!SWIG_IsOK(res1)) {
21506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21507 }
21508 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21509 {
21510 PyThreadState* __tstate = wxPyBeginAllowThreads();
21511 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21512 wxPyEndAllowThreads(__tstate);
21513 if (PyErr_Occurred()) SWIG_fail;
21514 }
21515 resultobj = SWIG_From_long(static_cast< long >(result));
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21523 PyObject *obj;
21524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21525 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21526 return SWIG_Py_Void();
21527 }
21528
21529 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj = 0;
21531 wxString const &arg1_defvalue = wxPyEmptyString ;
21532 wxString *arg1 = (wxString *) &arg1_defvalue ;
21533 wxString const &arg2_defvalue = wxPyEmptyString ;
21534 wxString *arg2 = (wxString *) &arg2_defvalue ;
21535 wxString const &arg3_defvalue = wxPyEmptyString ;
21536 wxString *arg3 = (wxString *) &arg3_defvalue ;
21537 wxString const &arg4_defvalue = wxPyEmptyString ;
21538 wxString *arg4 = (wxString *) &arg4_defvalue ;
21539 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21540 wxConfig *result = 0 ;
21541 bool temp1 = false ;
21542 bool temp2 = false ;
21543 bool temp3 = false ;
21544 bool temp4 = false ;
21545 long val5 ;
21546 int ecode5 = 0 ;
21547 PyObject * obj0 = 0 ;
21548 PyObject * obj1 = 0 ;
21549 PyObject * obj2 = 0 ;
21550 PyObject * obj3 = 0 ;
21551 PyObject * obj4 = 0 ;
21552 char * kwnames[] = {
21553 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21554 };
21555
21556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21557 if (obj0) {
21558 {
21559 arg1 = wxString_in_helper(obj0);
21560 if (arg1 == NULL) SWIG_fail;
21561 temp1 = true;
21562 }
21563 }
21564 if (obj1) {
21565 {
21566 arg2 = wxString_in_helper(obj1);
21567 if (arg2 == NULL) SWIG_fail;
21568 temp2 = true;
21569 }
21570 }
21571 if (obj2) {
21572 {
21573 arg3 = wxString_in_helper(obj2);
21574 if (arg3 == NULL) SWIG_fail;
21575 temp3 = true;
21576 }
21577 }
21578 if (obj3) {
21579 {
21580 arg4 = wxString_in_helper(obj3);
21581 if (arg4 == NULL) SWIG_fail;
21582 temp4 = true;
21583 }
21584 }
21585 if (obj4) {
21586 ecode5 = SWIG_AsVal_long(obj4, &val5);
21587 if (!SWIG_IsOK(ecode5)) {
21588 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21589 }
21590 arg5 = static_cast< long >(val5);
21591 }
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21595 wxPyEndAllowThreads(__tstate);
21596 if (PyErr_Occurred()) SWIG_fail;
21597 }
21598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21599 {
21600 if (temp1)
21601 delete arg1;
21602 }
21603 {
21604 if (temp2)
21605 delete arg2;
21606 }
21607 {
21608 if (temp3)
21609 delete arg3;
21610 }
21611 {
21612 if (temp4)
21613 delete arg4;
21614 }
21615 return resultobj;
21616 fail:
21617 {
21618 if (temp1)
21619 delete arg1;
21620 }
21621 {
21622 if (temp2)
21623 delete arg2;
21624 }
21625 {
21626 if (temp3)
21627 delete arg3;
21628 }
21629 {
21630 if (temp4)
21631 delete arg4;
21632 }
21633 return NULL;
21634 }
21635
21636
21637 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21638 PyObject *resultobj = 0;
21639 wxConfig *arg1 = (wxConfig *) 0 ;
21640 void *argp1 = 0 ;
21641 int res1 = 0 ;
21642 PyObject *swig_obj[1] ;
21643
21644 if (!args) SWIG_fail;
21645 swig_obj[0] = args;
21646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21647 if (!SWIG_IsOK(res1)) {
21648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21649 }
21650 arg1 = reinterpret_cast< wxConfig * >(argp1);
21651 {
21652 PyThreadState* __tstate = wxPyBeginAllowThreads();
21653 delete arg1;
21654
21655 wxPyEndAllowThreads(__tstate);
21656 if (PyErr_Occurred()) SWIG_fail;
21657 }
21658 resultobj = SWIG_Py_Void();
21659 return resultobj;
21660 fail:
21661 return NULL;
21662 }
21663
21664
21665 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21666 PyObject *obj;
21667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21668 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21669 return SWIG_Py_Void();
21670 }
21671
21672 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21673 return SWIG_Python_InitShadowInstance(args);
21674 }
21675
21676 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21677 PyObject *resultobj = 0;
21678 wxString const &arg1_defvalue = wxPyEmptyString ;
21679 wxString *arg1 = (wxString *) &arg1_defvalue ;
21680 wxString const &arg2_defvalue = wxPyEmptyString ;
21681 wxString *arg2 = (wxString *) &arg2_defvalue ;
21682 wxString const &arg3_defvalue = wxPyEmptyString ;
21683 wxString *arg3 = (wxString *) &arg3_defvalue ;
21684 wxString const &arg4_defvalue = wxPyEmptyString ;
21685 wxString *arg4 = (wxString *) &arg4_defvalue ;
21686 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21687 wxFileConfig *result = 0 ;
21688 bool temp1 = false ;
21689 bool temp2 = false ;
21690 bool temp3 = false ;
21691 bool temp4 = false ;
21692 long val5 ;
21693 int ecode5 = 0 ;
21694 PyObject * obj0 = 0 ;
21695 PyObject * obj1 = 0 ;
21696 PyObject * obj2 = 0 ;
21697 PyObject * obj3 = 0 ;
21698 PyObject * obj4 = 0 ;
21699 char * kwnames[] = {
21700 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21701 };
21702
21703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21704 if (obj0) {
21705 {
21706 arg1 = wxString_in_helper(obj0);
21707 if (arg1 == NULL) SWIG_fail;
21708 temp1 = true;
21709 }
21710 }
21711 if (obj1) {
21712 {
21713 arg2 = wxString_in_helper(obj1);
21714 if (arg2 == NULL) SWIG_fail;
21715 temp2 = true;
21716 }
21717 }
21718 if (obj2) {
21719 {
21720 arg3 = wxString_in_helper(obj2);
21721 if (arg3 == NULL) SWIG_fail;
21722 temp3 = true;
21723 }
21724 }
21725 if (obj3) {
21726 {
21727 arg4 = wxString_in_helper(obj3);
21728 if (arg4 == NULL) SWIG_fail;
21729 temp4 = true;
21730 }
21731 }
21732 if (obj4) {
21733 ecode5 = SWIG_AsVal_long(obj4, &val5);
21734 if (!SWIG_IsOK(ecode5)) {
21735 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21736 }
21737 arg5 = static_cast< long >(val5);
21738 }
21739 {
21740 PyThreadState* __tstate = wxPyBeginAllowThreads();
21741 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21742 wxPyEndAllowThreads(__tstate);
21743 if (PyErr_Occurred()) SWIG_fail;
21744 }
21745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21746 {
21747 if (temp1)
21748 delete arg1;
21749 }
21750 {
21751 if (temp2)
21752 delete arg2;
21753 }
21754 {
21755 if (temp3)
21756 delete arg3;
21757 }
21758 {
21759 if (temp4)
21760 delete arg4;
21761 }
21762 return resultobj;
21763 fail:
21764 {
21765 if (temp1)
21766 delete arg1;
21767 }
21768 {
21769 if (temp2)
21770 delete arg2;
21771 }
21772 {
21773 if (temp3)
21774 delete arg3;
21775 }
21776 {
21777 if (temp4)
21778 delete arg4;
21779 }
21780 return NULL;
21781 }
21782
21783
21784 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785 PyObject *resultobj = 0;
21786 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21787 void *argp1 = 0 ;
21788 int res1 = 0 ;
21789 PyObject *swig_obj[1] ;
21790
21791 if (!args) SWIG_fail;
21792 swig_obj[0] = args;
21793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21794 if (!SWIG_IsOK(res1)) {
21795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21796 }
21797 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21798 {
21799 PyThreadState* __tstate = wxPyBeginAllowThreads();
21800 delete arg1;
21801
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 resultobj = SWIG_Py_Void();
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21813 PyObject *obj;
21814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21815 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21816 return SWIG_Py_Void();
21817 }
21818
21819 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21820 return SWIG_Python_InitShadowInstance(args);
21821 }
21822
21823 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj = 0;
21825 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21826 wxString *arg2 = 0 ;
21827 wxConfigPathChanger *result = 0 ;
21828 void *argp1 = 0 ;
21829 int res1 = 0 ;
21830 bool temp2 = false ;
21831 PyObject * obj0 = 0 ;
21832 PyObject * obj1 = 0 ;
21833 char * kwnames[] = {
21834 (char *) "config",(char *) "entry", NULL
21835 };
21836
21837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21839 if (!SWIG_IsOK(res1)) {
21840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21841 }
21842 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21843 {
21844 arg2 = wxString_in_helper(obj1);
21845 if (arg2 == NULL) SWIG_fail;
21846 temp2 = true;
21847 }
21848 {
21849 PyThreadState* __tstate = wxPyBeginAllowThreads();
21850 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21851 wxPyEndAllowThreads(__tstate);
21852 if (PyErr_Occurred()) SWIG_fail;
21853 }
21854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21855 {
21856 if (temp2)
21857 delete arg2;
21858 }
21859 return resultobj;
21860 fail:
21861 {
21862 if (temp2)
21863 delete arg2;
21864 }
21865 return NULL;
21866 }
21867
21868
21869 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21870 PyObject *resultobj = 0;
21871 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21872 void *argp1 = 0 ;
21873 int res1 = 0 ;
21874 PyObject *swig_obj[1] ;
21875
21876 if (!args) SWIG_fail;
21877 swig_obj[0] = args;
21878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21879 if (!SWIG_IsOK(res1)) {
21880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21881 }
21882 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 delete arg1;
21886
21887 wxPyEndAllowThreads(__tstate);
21888 if (PyErr_Occurred()) SWIG_fail;
21889 }
21890 resultobj = SWIG_Py_Void();
21891 return resultobj;
21892 fail:
21893 return NULL;
21894 }
21895
21896
21897 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21898 PyObject *resultobj = 0;
21899 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21900 wxString *result = 0 ;
21901 void *argp1 = 0 ;
21902 int res1 = 0 ;
21903 PyObject *swig_obj[1] ;
21904
21905 if (!args) SWIG_fail;
21906 swig_obj[0] = args;
21907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21908 if (!SWIG_IsOK(res1)) {
21909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21910 }
21911 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 {
21915 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21916 result = (wxString *) &_result_ref;
21917 }
21918 wxPyEndAllowThreads(__tstate);
21919 if (PyErr_Occurred()) SWIG_fail;
21920 }
21921 {
21922 #if wxUSE_UNICODE
21923 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21924 #else
21925 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21926 #endif
21927 }
21928 return resultobj;
21929 fail:
21930 return NULL;
21931 }
21932
21933
21934 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21935 PyObject *obj;
21936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21937 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21938 return SWIG_Py_Void();
21939 }
21940
21941 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21942 return SWIG_Python_InitShadowInstance(args);
21943 }
21944
21945 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21946 PyObject *resultobj = 0;
21947 wxString *arg1 = 0 ;
21948 wxString result;
21949 bool temp1 = false ;
21950 PyObject * obj0 = 0 ;
21951 char * kwnames[] = {
21952 (char *) "sz", NULL
21953 };
21954
21955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21956 {
21957 arg1 = wxString_in_helper(obj0);
21958 if (arg1 == NULL) SWIG_fail;
21959 temp1 = true;
21960 }
21961 {
21962 PyThreadState* __tstate = wxPyBeginAllowThreads();
21963 result = wxExpandEnvVars((wxString const &)*arg1);
21964 wxPyEndAllowThreads(__tstate);
21965 if (PyErr_Occurred()) SWIG_fail;
21966 }
21967 {
21968 #if wxUSE_UNICODE
21969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21970 #else
21971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21972 #endif
21973 }
21974 {
21975 if (temp1)
21976 delete arg1;
21977 }
21978 return resultobj;
21979 fail:
21980 {
21981 if (temp1)
21982 delete arg1;
21983 }
21984 return NULL;
21985 }
21986
21987
21988 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21989 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21990 return 1;
21991 }
21992
21993
21994 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21995 PyObject *pyobj = 0;
21996
21997 {
21998 #if wxUSE_UNICODE
21999 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22000 #else
22001 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22002 #endif
22003 }
22004 return pyobj;
22005 }
22006
22007
22008 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22009 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22010 return 1;
22011 }
22012
22013
22014 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22015 PyObject *pyobj = 0;
22016
22017 {
22018 #if wxUSE_UNICODE
22019 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22020 #else
22021 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22022 #endif
22023 }
22024 return pyobj;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22029 PyObject *resultobj = 0;
22030 wxDateTime::Country arg1 ;
22031 int val1 ;
22032 int ecode1 = 0 ;
22033 PyObject * obj0 = 0 ;
22034 char * kwnames[] = {
22035 (char *) "country", NULL
22036 };
22037
22038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22039 ecode1 = SWIG_AsVal_int(obj0, &val1);
22040 if (!SWIG_IsOK(ecode1)) {
22041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22042 }
22043 arg1 = static_cast< wxDateTime::Country >(val1);
22044 {
22045 PyThreadState* __tstate = wxPyBeginAllowThreads();
22046 wxDateTime::SetCountry(arg1);
22047 wxPyEndAllowThreads(__tstate);
22048 if (PyErr_Occurred()) SWIG_fail;
22049 }
22050 resultobj = SWIG_Py_Void();
22051 return resultobj;
22052 fail:
22053 return NULL;
22054 }
22055
22056
22057 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22058 PyObject *resultobj = 0;
22059 wxDateTime::Country result;
22060
22061 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22062 {
22063 PyThreadState* __tstate = wxPyBeginAllowThreads();
22064 result = (wxDateTime::Country)wxDateTime::GetCountry();
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 resultobj = SWIG_From_int(static_cast< int >(result));
22069 return resultobj;
22070 fail:
22071 return NULL;
22072 }
22073
22074
22075 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22076 PyObject *resultobj = 0;
22077 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22078 bool result;
22079 int val1 ;
22080 int ecode1 = 0 ;
22081 PyObject * obj0 = 0 ;
22082 char * kwnames[] = {
22083 (char *) "country", NULL
22084 };
22085
22086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22087 if (obj0) {
22088 ecode1 = SWIG_AsVal_int(obj0, &val1);
22089 if (!SWIG_IsOK(ecode1)) {
22090 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22091 }
22092 arg1 = static_cast< wxDateTime::Country >(val1);
22093 }
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 {
22101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22102 }
22103 return resultobj;
22104 fail:
22105 return NULL;
22106 }
22107
22108
22109 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22110 PyObject *resultobj = 0;
22111 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22112 int result;
22113 int val1 ;
22114 int ecode1 = 0 ;
22115 PyObject * obj0 = 0 ;
22116 char * kwnames[] = {
22117 (char *) "cal", NULL
22118 };
22119
22120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
22121 if (obj0) {
22122 ecode1 = SWIG_AsVal_int(obj0, &val1);
22123 if (!SWIG_IsOK(ecode1)) {
22124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22125 }
22126 arg1 = static_cast< wxDateTime::Calendar >(val1);
22127 }
22128 {
22129 PyThreadState* __tstate = wxPyBeginAllowThreads();
22130 result = (int)wxDateTime::GetCurrentYear(arg1);
22131 wxPyEndAllowThreads(__tstate);
22132 if (PyErr_Occurred()) SWIG_fail;
22133 }
22134 resultobj = SWIG_From_int(static_cast< int >(result));
22135 return resultobj;
22136 fail:
22137 return NULL;
22138 }
22139
22140
22141 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22142 PyObject *resultobj = 0;
22143 int arg1 ;
22144 int result;
22145 int val1 ;
22146 int ecode1 = 0 ;
22147 PyObject * obj0 = 0 ;
22148 char * kwnames[] = {
22149 (char *) "year", NULL
22150 };
22151
22152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
22153 ecode1 = SWIG_AsVal_int(obj0, &val1);
22154 if (!SWIG_IsOK(ecode1)) {
22155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
22156 }
22157 arg1 = static_cast< int >(val1);
22158 {
22159 PyThreadState* __tstate = wxPyBeginAllowThreads();
22160 result = (int)wxDateTime::ConvertYearToBC(arg1);
22161 wxPyEndAllowThreads(__tstate);
22162 if (PyErr_Occurred()) SWIG_fail;
22163 }
22164 resultobj = SWIG_From_int(static_cast< int >(result));
22165 return resultobj;
22166 fail:
22167 return NULL;
22168 }
22169
22170
22171 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22172 PyObject *resultobj = 0;
22173 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22174 wxDateTime::Month result;
22175 int val1 ;
22176 int ecode1 = 0 ;
22177 PyObject * obj0 = 0 ;
22178 char * kwnames[] = {
22179 (char *) "cal", NULL
22180 };
22181
22182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22183 if (obj0) {
22184 ecode1 = SWIG_AsVal_int(obj0, &val1);
22185 if (!SWIG_IsOK(ecode1)) {
22186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22187 }
22188 arg1 = static_cast< wxDateTime::Calendar >(val1);
22189 }
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22193 wxPyEndAllowThreads(__tstate);
22194 if (PyErr_Occurred()) SWIG_fail;
22195 }
22196 resultobj = SWIG_From_int(static_cast< int >(result));
22197 return resultobj;
22198 fail:
22199 return NULL;
22200 }
22201
22202
22203 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22204 PyObject *resultobj = 0;
22205 int arg1 = (int) wxDateTime::Inv_Year ;
22206 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22207 bool result;
22208 int val1 ;
22209 int ecode1 = 0 ;
22210 int val2 ;
22211 int ecode2 = 0 ;
22212 PyObject * obj0 = 0 ;
22213 PyObject * obj1 = 0 ;
22214 char * kwnames[] = {
22215 (char *) "year",(char *) "cal", NULL
22216 };
22217
22218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22219 if (obj0) {
22220 ecode1 = SWIG_AsVal_int(obj0, &val1);
22221 if (!SWIG_IsOK(ecode1)) {
22222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22223 }
22224 arg1 = static_cast< int >(val1);
22225 }
22226 if (obj1) {
22227 ecode2 = SWIG_AsVal_int(obj1, &val2);
22228 if (!SWIG_IsOK(ecode2)) {
22229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22230 }
22231 arg2 = static_cast< wxDateTime::Calendar >(val2);
22232 }
22233 {
22234 PyThreadState* __tstate = wxPyBeginAllowThreads();
22235 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22236 wxPyEndAllowThreads(__tstate);
22237 if (PyErr_Occurred()) SWIG_fail;
22238 }
22239 {
22240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22241 }
22242 return resultobj;
22243 fail:
22244 return NULL;
22245 }
22246
22247
22248 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22249 PyObject *resultobj = 0;
22250 int arg1 = (int) wxDateTime::Inv_Year ;
22251 int result;
22252 int val1 ;
22253 int ecode1 = 0 ;
22254 PyObject * obj0 = 0 ;
22255 char * kwnames[] = {
22256 (char *) "year", NULL
22257 };
22258
22259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22260 if (obj0) {
22261 ecode1 = SWIG_AsVal_int(obj0, &val1);
22262 if (!SWIG_IsOK(ecode1)) {
22263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22264 }
22265 arg1 = static_cast< int >(val1);
22266 }
22267 {
22268 PyThreadState* __tstate = wxPyBeginAllowThreads();
22269 result = (int)wxDateTime::GetCentury(arg1);
22270 wxPyEndAllowThreads(__tstate);
22271 if (PyErr_Occurred()) SWIG_fail;
22272 }
22273 resultobj = SWIG_From_int(static_cast< int >(result));
22274 return resultobj;
22275 fail:
22276 return NULL;
22277 }
22278
22279
22280 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22281 PyObject *resultobj = 0;
22282 int arg1 ;
22283 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22284 int result;
22285 int val1 ;
22286 int ecode1 = 0 ;
22287 int val2 ;
22288 int ecode2 = 0 ;
22289 PyObject * obj0 = 0 ;
22290 PyObject * obj1 = 0 ;
22291 char * kwnames[] = {
22292 (char *) "year",(char *) "cal", NULL
22293 };
22294
22295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22296 ecode1 = SWIG_AsVal_int(obj0, &val1);
22297 if (!SWIG_IsOK(ecode1)) {
22298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22299 }
22300 arg1 = static_cast< int >(val1);
22301 if (obj1) {
22302 ecode2 = SWIG_AsVal_int(obj1, &val2);
22303 if (!SWIG_IsOK(ecode2)) {
22304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22305 }
22306 arg2 = static_cast< wxDateTime::Calendar >(val2);
22307 }
22308 {
22309 PyThreadState* __tstate = wxPyBeginAllowThreads();
22310 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22311 wxPyEndAllowThreads(__tstate);
22312 if (PyErr_Occurred()) SWIG_fail;
22313 }
22314 resultobj = SWIG_From_int(static_cast< int >(result));
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22322 PyObject *resultobj = 0;
22323 wxDateTime::Month arg1 ;
22324 int arg2 = (int) wxDateTime::Inv_Year ;
22325 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22326 int result;
22327 int val1 ;
22328 int ecode1 = 0 ;
22329 int val2 ;
22330 int ecode2 = 0 ;
22331 int val3 ;
22332 int ecode3 = 0 ;
22333 PyObject * obj0 = 0 ;
22334 PyObject * obj1 = 0 ;
22335 PyObject * obj2 = 0 ;
22336 char * kwnames[] = {
22337 (char *) "month",(char *) "year",(char *) "cal", NULL
22338 };
22339
22340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22341 ecode1 = SWIG_AsVal_int(obj0, &val1);
22342 if (!SWIG_IsOK(ecode1)) {
22343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22344 }
22345 arg1 = static_cast< wxDateTime::Month >(val1);
22346 if (obj1) {
22347 ecode2 = SWIG_AsVal_int(obj1, &val2);
22348 if (!SWIG_IsOK(ecode2)) {
22349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22350 }
22351 arg2 = static_cast< int >(val2);
22352 }
22353 if (obj2) {
22354 ecode3 = SWIG_AsVal_int(obj2, &val3);
22355 if (!SWIG_IsOK(ecode3)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22357 }
22358 arg3 = static_cast< wxDateTime::Calendar >(val3);
22359 }
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22363 wxPyEndAllowThreads(__tstate);
22364 if (PyErr_Occurred()) SWIG_fail;
22365 }
22366 resultobj = SWIG_From_int(static_cast< int >(result));
22367 return resultobj;
22368 fail:
22369 return NULL;
22370 }
22371
22372
22373 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22374 PyObject *resultobj = 0;
22375 wxDateTime::Month arg1 ;
22376 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22377 wxString result;
22378 int val1 ;
22379 int ecode1 = 0 ;
22380 int val2 ;
22381 int ecode2 = 0 ;
22382 PyObject * obj0 = 0 ;
22383 PyObject * obj1 = 0 ;
22384 char * kwnames[] = {
22385 (char *) "month",(char *) "flags", NULL
22386 };
22387
22388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22389 ecode1 = SWIG_AsVal_int(obj0, &val1);
22390 if (!SWIG_IsOK(ecode1)) {
22391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22392 }
22393 arg1 = static_cast< wxDateTime::Month >(val1);
22394 if (obj1) {
22395 ecode2 = SWIG_AsVal_int(obj1, &val2);
22396 if (!SWIG_IsOK(ecode2)) {
22397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22398 }
22399 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22400 }
22401 {
22402 PyThreadState* __tstate = wxPyBeginAllowThreads();
22403 result = wxDateTime::GetMonthName(arg1,arg2);
22404 wxPyEndAllowThreads(__tstate);
22405 if (PyErr_Occurred()) SWIG_fail;
22406 }
22407 {
22408 #if wxUSE_UNICODE
22409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22410 #else
22411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22412 #endif
22413 }
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22421 PyObject *resultobj = 0;
22422 wxDateTime::WeekDay arg1 ;
22423 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22424 wxString result;
22425 int val1 ;
22426 int ecode1 = 0 ;
22427 int val2 ;
22428 int ecode2 = 0 ;
22429 PyObject * obj0 = 0 ;
22430 PyObject * obj1 = 0 ;
22431 char * kwnames[] = {
22432 (char *) "weekday",(char *) "flags", NULL
22433 };
22434
22435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22436 ecode1 = SWIG_AsVal_int(obj0, &val1);
22437 if (!SWIG_IsOK(ecode1)) {
22438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22439 }
22440 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22441 if (obj1) {
22442 ecode2 = SWIG_AsVal_int(obj1, &val2);
22443 if (!SWIG_IsOK(ecode2)) {
22444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22445 }
22446 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22447 }
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = wxDateTime::GetWeekDayName(arg1,arg2);
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 {
22455 #if wxUSE_UNICODE
22456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22457 #else
22458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22459 #endif
22460 }
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22468 PyObject *resultobj = 0;
22469 PyObject *result = 0 ;
22470
22471 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22472 {
22473 PyThreadState* __tstate = wxPyBeginAllowThreads();
22474 result = (PyObject *)wxDateTime_GetAmPmStrings();
22475 wxPyEndAllowThreads(__tstate);
22476 if (PyErr_Occurred()) SWIG_fail;
22477 }
22478 resultobj = result;
22479 return resultobj;
22480 fail:
22481 return NULL;
22482 }
22483
22484
22485 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22486 PyObject *resultobj = 0;
22487 int arg1 = (int) wxDateTime::Inv_Year ;
22488 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22489 bool result;
22490 int val1 ;
22491 int ecode1 = 0 ;
22492 int val2 ;
22493 int ecode2 = 0 ;
22494 PyObject * obj0 = 0 ;
22495 PyObject * obj1 = 0 ;
22496 char * kwnames[] = {
22497 (char *) "year",(char *) "country", NULL
22498 };
22499
22500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22501 if (obj0) {
22502 ecode1 = SWIG_AsVal_int(obj0, &val1);
22503 if (!SWIG_IsOK(ecode1)) {
22504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22505 }
22506 arg1 = static_cast< int >(val1);
22507 }
22508 if (obj1) {
22509 ecode2 = SWIG_AsVal_int(obj1, &val2);
22510 if (!SWIG_IsOK(ecode2)) {
22511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22512 }
22513 arg2 = static_cast< wxDateTime::Country >(val2);
22514 }
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22518 wxPyEndAllowThreads(__tstate);
22519 if (PyErr_Occurred()) SWIG_fail;
22520 }
22521 {
22522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22523 }
22524 return resultobj;
22525 fail:
22526 return NULL;
22527 }
22528
22529
22530 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22531 PyObject *resultobj = 0;
22532 int arg1 = (int) wxDateTime::Inv_Year ;
22533 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22534 wxDateTime result;
22535 int val1 ;
22536 int ecode1 = 0 ;
22537 int val2 ;
22538 int ecode2 = 0 ;
22539 PyObject * obj0 = 0 ;
22540 PyObject * obj1 = 0 ;
22541 char * kwnames[] = {
22542 (char *) "year",(char *) "country", NULL
22543 };
22544
22545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22546 if (obj0) {
22547 ecode1 = SWIG_AsVal_int(obj0, &val1);
22548 if (!SWIG_IsOK(ecode1)) {
22549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22550 }
22551 arg1 = static_cast< int >(val1);
22552 }
22553 if (obj1) {
22554 ecode2 = SWIG_AsVal_int(obj1, &val2);
22555 if (!SWIG_IsOK(ecode2)) {
22556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22557 }
22558 arg2 = static_cast< wxDateTime::Country >(val2);
22559 }
22560 {
22561 PyThreadState* __tstate = wxPyBeginAllowThreads();
22562 result = wxDateTime::GetBeginDST(arg1,arg2);
22563 wxPyEndAllowThreads(__tstate);
22564 if (PyErr_Occurred()) SWIG_fail;
22565 }
22566 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22567 return resultobj;
22568 fail:
22569 return NULL;
22570 }
22571
22572
22573 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22574 PyObject *resultobj = 0;
22575 int arg1 = (int) wxDateTime::Inv_Year ;
22576 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22577 wxDateTime result;
22578 int val1 ;
22579 int ecode1 = 0 ;
22580 int val2 ;
22581 int ecode2 = 0 ;
22582 PyObject * obj0 = 0 ;
22583 PyObject * obj1 = 0 ;
22584 char * kwnames[] = {
22585 (char *) "year",(char *) "country", NULL
22586 };
22587
22588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22589 if (obj0) {
22590 ecode1 = SWIG_AsVal_int(obj0, &val1);
22591 if (!SWIG_IsOK(ecode1)) {
22592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22593 }
22594 arg1 = static_cast< int >(val1);
22595 }
22596 if (obj1) {
22597 ecode2 = SWIG_AsVal_int(obj1, &val2);
22598 if (!SWIG_IsOK(ecode2)) {
22599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22600 }
22601 arg2 = static_cast< wxDateTime::Country >(val2);
22602 }
22603 {
22604 PyThreadState* __tstate = wxPyBeginAllowThreads();
22605 result = wxDateTime::GetEndDST(arg1,arg2);
22606 wxPyEndAllowThreads(__tstate);
22607 if (PyErr_Occurred()) SWIG_fail;
22608 }
22609 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22610 return resultobj;
22611 fail:
22612 return NULL;
22613 }
22614
22615
22616 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22617 PyObject *resultobj = 0;
22618 wxDateTime result;
22619
22620 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22621 {
22622 PyThreadState* __tstate = wxPyBeginAllowThreads();
22623 result = wxDateTime::Now();
22624 wxPyEndAllowThreads(__tstate);
22625 if (PyErr_Occurred()) SWIG_fail;
22626 }
22627 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22635 PyObject *resultobj = 0;
22636 wxDateTime result;
22637
22638 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22639 {
22640 PyThreadState* __tstate = wxPyBeginAllowThreads();
22641 result = wxDateTime::UNow();
22642 wxPyEndAllowThreads(__tstate);
22643 if (PyErr_Occurred()) SWIG_fail;
22644 }
22645 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22646 return resultobj;
22647 fail:
22648 return NULL;
22649 }
22650
22651
22652 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22653 PyObject *resultobj = 0;
22654 wxDateTime result;
22655
22656 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22657 {
22658 PyThreadState* __tstate = wxPyBeginAllowThreads();
22659 result = wxDateTime::Today();
22660 wxPyEndAllowThreads(__tstate);
22661 if (PyErr_Occurred()) SWIG_fail;
22662 }
22663 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22664 return resultobj;
22665 fail:
22666 return NULL;
22667 }
22668
22669
22670 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22671 PyObject *resultobj = 0;
22672 wxDateTime *result = 0 ;
22673
22674 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22675 {
22676 PyThreadState* __tstate = wxPyBeginAllowThreads();
22677 result = (wxDateTime *)new wxDateTime();
22678 wxPyEndAllowThreads(__tstate);
22679 if (PyErr_Occurred()) SWIG_fail;
22680 }
22681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22682 return resultobj;
22683 fail:
22684 return NULL;
22685 }
22686
22687
22688 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22689 PyObject *resultobj = 0;
22690 time_t arg1 ;
22691 wxDateTime *result = 0 ;
22692 unsigned int val1 ;
22693 int ecode1 = 0 ;
22694 PyObject * obj0 = 0 ;
22695 char * kwnames[] = {
22696 (char *) "timet", NULL
22697 };
22698
22699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22700 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22701 if (!SWIG_IsOK(ecode1)) {
22702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22703 }
22704 arg1 = static_cast< time_t >(val1);
22705 {
22706 PyThreadState* __tstate = wxPyBeginAllowThreads();
22707 result = (wxDateTime *)new wxDateTime(arg1);
22708 wxPyEndAllowThreads(__tstate);
22709 if (PyErr_Occurred()) SWIG_fail;
22710 }
22711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22712 return resultobj;
22713 fail:
22714 return NULL;
22715 }
22716
22717
22718 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22719 PyObject *resultobj = 0;
22720 double arg1 ;
22721 wxDateTime *result = 0 ;
22722 double val1 ;
22723 int ecode1 = 0 ;
22724 PyObject * obj0 = 0 ;
22725 char * kwnames[] = {
22726 (char *) "jdn", NULL
22727 };
22728
22729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22730 ecode1 = SWIG_AsVal_double(obj0, &val1);
22731 if (!SWIG_IsOK(ecode1)) {
22732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22733 }
22734 arg1 = static_cast< double >(val1);
22735 {
22736 PyThreadState* __tstate = wxPyBeginAllowThreads();
22737 result = (wxDateTime *)new wxDateTime(arg1);
22738 wxPyEndAllowThreads(__tstate);
22739 if (PyErr_Occurred()) SWIG_fail;
22740 }
22741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22742 return resultobj;
22743 fail:
22744 return NULL;
22745 }
22746
22747
22748 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22749 PyObject *resultobj = 0;
22750 int arg1 ;
22751 int arg2 = (int) 0 ;
22752 int arg3 = (int) 0 ;
22753 int arg4 = (int) 0 ;
22754 wxDateTime *result = 0 ;
22755 int val1 ;
22756 int ecode1 = 0 ;
22757 int val2 ;
22758 int ecode2 = 0 ;
22759 int val3 ;
22760 int ecode3 = 0 ;
22761 int val4 ;
22762 int ecode4 = 0 ;
22763 PyObject * obj0 = 0 ;
22764 PyObject * obj1 = 0 ;
22765 PyObject * obj2 = 0 ;
22766 PyObject * obj3 = 0 ;
22767 char * kwnames[] = {
22768 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22769 };
22770
22771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22772 ecode1 = SWIG_AsVal_int(obj0, &val1);
22773 if (!SWIG_IsOK(ecode1)) {
22774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22775 }
22776 arg1 = static_cast< int >(val1);
22777 if (obj1) {
22778 ecode2 = SWIG_AsVal_int(obj1, &val2);
22779 if (!SWIG_IsOK(ecode2)) {
22780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22781 }
22782 arg2 = static_cast< int >(val2);
22783 }
22784 if (obj2) {
22785 ecode3 = SWIG_AsVal_int(obj2, &val3);
22786 if (!SWIG_IsOK(ecode3)) {
22787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22788 }
22789 arg3 = static_cast< int >(val3);
22790 }
22791 if (obj3) {
22792 ecode4 = SWIG_AsVal_int(obj3, &val4);
22793 if (!SWIG_IsOK(ecode4)) {
22794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22795 }
22796 arg4 = static_cast< int >(val4);
22797 }
22798 {
22799 PyThreadState* __tstate = wxPyBeginAllowThreads();
22800 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22801 wxPyEndAllowThreads(__tstate);
22802 if (PyErr_Occurred()) SWIG_fail;
22803 }
22804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22805 return resultobj;
22806 fail:
22807 return NULL;
22808 }
22809
22810
22811 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22812 PyObject *resultobj = 0;
22813 int arg1 ;
22814 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22815 int arg3 = (int) wxDateTime::Inv_Year ;
22816 int arg4 = (int) 0 ;
22817 int arg5 = (int) 0 ;
22818 int arg6 = (int) 0 ;
22819 int arg7 = (int) 0 ;
22820 wxDateTime *result = 0 ;
22821 int val1 ;
22822 int ecode1 = 0 ;
22823 int val2 ;
22824 int ecode2 = 0 ;
22825 int val3 ;
22826 int ecode3 = 0 ;
22827 int val4 ;
22828 int ecode4 = 0 ;
22829 int val5 ;
22830 int ecode5 = 0 ;
22831 int val6 ;
22832 int ecode6 = 0 ;
22833 int val7 ;
22834 int ecode7 = 0 ;
22835 PyObject * obj0 = 0 ;
22836 PyObject * obj1 = 0 ;
22837 PyObject * obj2 = 0 ;
22838 PyObject * obj3 = 0 ;
22839 PyObject * obj4 = 0 ;
22840 PyObject * obj5 = 0 ;
22841 PyObject * obj6 = 0 ;
22842 char * kwnames[] = {
22843 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22844 };
22845
22846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22847 ecode1 = SWIG_AsVal_int(obj0, &val1);
22848 if (!SWIG_IsOK(ecode1)) {
22849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22850 }
22851 arg1 = static_cast< int >(val1);
22852 if (obj1) {
22853 ecode2 = SWIG_AsVal_int(obj1, &val2);
22854 if (!SWIG_IsOK(ecode2)) {
22855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22856 }
22857 arg2 = static_cast< wxDateTime::Month >(val2);
22858 }
22859 if (obj2) {
22860 ecode3 = SWIG_AsVal_int(obj2, &val3);
22861 if (!SWIG_IsOK(ecode3)) {
22862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22863 }
22864 arg3 = static_cast< int >(val3);
22865 }
22866 if (obj3) {
22867 ecode4 = SWIG_AsVal_int(obj3, &val4);
22868 if (!SWIG_IsOK(ecode4)) {
22869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22870 }
22871 arg4 = static_cast< int >(val4);
22872 }
22873 if (obj4) {
22874 ecode5 = SWIG_AsVal_int(obj4, &val5);
22875 if (!SWIG_IsOK(ecode5)) {
22876 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22877 }
22878 arg5 = static_cast< int >(val5);
22879 }
22880 if (obj5) {
22881 ecode6 = SWIG_AsVal_int(obj5, &val6);
22882 if (!SWIG_IsOK(ecode6)) {
22883 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22884 }
22885 arg6 = static_cast< int >(val6);
22886 }
22887 if (obj6) {
22888 ecode7 = SWIG_AsVal_int(obj6, &val7);
22889 if (!SWIG_IsOK(ecode7)) {
22890 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22891 }
22892 arg7 = static_cast< int >(val7);
22893 }
22894 {
22895 PyThreadState* __tstate = wxPyBeginAllowThreads();
22896 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22897 wxPyEndAllowThreads(__tstate);
22898 if (PyErr_Occurred()) SWIG_fail;
22899 }
22900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22908 PyObject *resultobj = 0;
22909 wxDateTime *arg1 = 0 ;
22910 wxDateTime *result = 0 ;
22911 void *argp1 = 0 ;
22912 int res1 = 0 ;
22913 PyObject * obj0 = 0 ;
22914 char * kwnames[] = {
22915 (char *) "date", NULL
22916 };
22917
22918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22919 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22920 if (!SWIG_IsOK(res1)) {
22921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22922 }
22923 if (!argp1) {
22924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22925 }
22926 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22927 {
22928 PyThreadState* __tstate = wxPyBeginAllowThreads();
22929 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22934 return resultobj;
22935 fail:
22936 return NULL;
22937 }
22938
22939
22940 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22941 PyObject *resultobj = 0;
22942 wxDateTime *arg1 = (wxDateTime *) 0 ;
22943 void *argp1 = 0 ;
22944 int res1 = 0 ;
22945 PyObject *swig_obj[1] ;
22946
22947 if (!args) SWIG_fail;
22948 swig_obj[0] = args;
22949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22950 if (!SWIG_IsOK(res1)) {
22951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22952 }
22953 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 delete arg1;
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 resultobj = SWIG_Py_Void();
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22969 PyObject *resultobj = 0;
22970 wxDateTime *arg1 = (wxDateTime *) 0 ;
22971 wxDateTime *result = 0 ;
22972 void *argp1 = 0 ;
22973 int res1 = 0 ;
22974 PyObject *swig_obj[1] ;
22975
22976 if (!args) SWIG_fail;
22977 swig_obj[0] = args;
22978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22979 if (!SWIG_IsOK(res1)) {
22980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22981 }
22982 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 {
22986 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22987 result = (wxDateTime *) &_result_ref;
22988 }
22989 wxPyEndAllowThreads(__tstate);
22990 if (PyErr_Occurred()) SWIG_fail;
22991 }
22992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22993 return resultobj;
22994 fail:
22995 return NULL;
22996 }
22997
22998
22999 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23000 PyObject *resultobj = 0;
23001 wxDateTime *arg1 = (wxDateTime *) 0 ;
23002 time_t arg2 ;
23003 wxDateTime *result = 0 ;
23004 void *argp1 = 0 ;
23005 int res1 = 0 ;
23006 unsigned int val2 ;
23007 int ecode2 = 0 ;
23008 PyObject * obj0 = 0 ;
23009 PyObject * obj1 = 0 ;
23010 char * kwnames[] = {
23011 (char *) "self",(char *) "timet", NULL
23012 };
23013
23014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23016 if (!SWIG_IsOK(res1)) {
23017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23018 }
23019 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23020 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23021 if (!SWIG_IsOK(ecode2)) {
23022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23023 }
23024 arg2 = static_cast< time_t >(val2);
23025 {
23026 PyThreadState* __tstate = wxPyBeginAllowThreads();
23027 {
23028 wxDateTime &_result_ref = (arg1)->Set(arg2);
23029 result = (wxDateTime *) &_result_ref;
23030 }
23031 wxPyEndAllowThreads(__tstate);
23032 if (PyErr_Occurred()) SWIG_fail;
23033 }
23034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23035 return resultobj;
23036 fail:
23037 return NULL;
23038 }
23039
23040
23041 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23042 PyObject *resultobj = 0;
23043 wxDateTime *arg1 = (wxDateTime *) 0 ;
23044 double arg2 ;
23045 wxDateTime *result = 0 ;
23046 void *argp1 = 0 ;
23047 int res1 = 0 ;
23048 double val2 ;
23049 int ecode2 = 0 ;
23050 PyObject * obj0 = 0 ;
23051 PyObject * obj1 = 0 ;
23052 char * kwnames[] = {
23053 (char *) "self",(char *) "jdn", NULL
23054 };
23055
23056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23058 if (!SWIG_IsOK(res1)) {
23059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23060 }
23061 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23062 ecode2 = SWIG_AsVal_double(obj1, &val2);
23063 if (!SWIG_IsOK(ecode2)) {
23064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23065 }
23066 arg2 = static_cast< double >(val2);
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 {
23070 wxDateTime &_result_ref = (arg1)->Set(arg2);
23071 result = (wxDateTime *) &_result_ref;
23072 }
23073 wxPyEndAllowThreads(__tstate);
23074 if (PyErr_Occurred()) SWIG_fail;
23075 }
23076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23077 return resultobj;
23078 fail:
23079 return NULL;
23080 }
23081
23082
23083 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23084 PyObject *resultobj = 0;
23085 wxDateTime *arg1 = (wxDateTime *) 0 ;
23086 int arg2 ;
23087 int arg3 = (int) 0 ;
23088 int arg4 = (int) 0 ;
23089 int arg5 = (int) 0 ;
23090 wxDateTime *result = 0 ;
23091 void *argp1 = 0 ;
23092 int res1 = 0 ;
23093 int val2 ;
23094 int ecode2 = 0 ;
23095 int val3 ;
23096 int ecode3 = 0 ;
23097 int val4 ;
23098 int ecode4 = 0 ;
23099 int val5 ;
23100 int ecode5 = 0 ;
23101 PyObject * obj0 = 0 ;
23102 PyObject * obj1 = 0 ;
23103 PyObject * obj2 = 0 ;
23104 PyObject * obj3 = 0 ;
23105 PyObject * obj4 = 0 ;
23106 char * kwnames[] = {
23107 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23108 };
23109
23110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23112 if (!SWIG_IsOK(res1)) {
23113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
23114 }
23115 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23116 ecode2 = SWIG_AsVal_int(obj1, &val2);
23117 if (!SWIG_IsOK(ecode2)) {
23118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
23119 }
23120 arg2 = static_cast< int >(val2);
23121 if (obj2) {
23122 ecode3 = SWIG_AsVal_int(obj2, &val3);
23123 if (!SWIG_IsOK(ecode3)) {
23124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
23125 }
23126 arg3 = static_cast< int >(val3);
23127 }
23128 if (obj3) {
23129 ecode4 = SWIG_AsVal_int(obj3, &val4);
23130 if (!SWIG_IsOK(ecode4)) {
23131 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
23132 }
23133 arg4 = static_cast< int >(val4);
23134 }
23135 if (obj4) {
23136 ecode5 = SWIG_AsVal_int(obj4, &val5);
23137 if (!SWIG_IsOK(ecode5)) {
23138 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
23139 }
23140 arg5 = static_cast< int >(val5);
23141 }
23142 {
23143 PyThreadState* __tstate = wxPyBeginAllowThreads();
23144 {
23145 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
23146 result = (wxDateTime *) &_result_ref;
23147 }
23148 wxPyEndAllowThreads(__tstate);
23149 if (PyErr_Occurred()) SWIG_fail;
23150 }
23151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23152 return resultobj;
23153 fail:
23154 return NULL;
23155 }
23156
23157
23158 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23159 PyObject *resultobj = 0;
23160 wxDateTime *arg1 = (wxDateTime *) 0 ;
23161 int arg2 ;
23162 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23163 int arg4 = (int) wxDateTime::Inv_Year ;
23164 int arg5 = (int) 0 ;
23165 int arg6 = (int) 0 ;
23166 int arg7 = (int) 0 ;
23167 int arg8 = (int) 0 ;
23168 wxDateTime *result = 0 ;
23169 void *argp1 = 0 ;
23170 int res1 = 0 ;
23171 int val2 ;
23172 int ecode2 = 0 ;
23173 int val3 ;
23174 int ecode3 = 0 ;
23175 int val4 ;
23176 int ecode4 = 0 ;
23177 int val5 ;
23178 int ecode5 = 0 ;
23179 int val6 ;
23180 int ecode6 = 0 ;
23181 int val7 ;
23182 int ecode7 = 0 ;
23183 int val8 ;
23184 int ecode8 = 0 ;
23185 PyObject * obj0 = 0 ;
23186 PyObject * obj1 = 0 ;
23187 PyObject * obj2 = 0 ;
23188 PyObject * obj3 = 0 ;
23189 PyObject * obj4 = 0 ;
23190 PyObject * obj5 = 0 ;
23191 PyObject * obj6 = 0 ;
23192 PyObject * obj7 = 0 ;
23193 char * kwnames[] = {
23194 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23195 };
23196
23197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23199 if (!SWIG_IsOK(res1)) {
23200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23201 }
23202 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23203 ecode2 = SWIG_AsVal_int(obj1, &val2);
23204 if (!SWIG_IsOK(ecode2)) {
23205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23206 }
23207 arg2 = static_cast< int >(val2);
23208 if (obj2) {
23209 ecode3 = SWIG_AsVal_int(obj2, &val3);
23210 if (!SWIG_IsOK(ecode3)) {
23211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23212 }
23213 arg3 = static_cast< wxDateTime::Month >(val3);
23214 }
23215 if (obj3) {
23216 ecode4 = SWIG_AsVal_int(obj3, &val4);
23217 if (!SWIG_IsOK(ecode4)) {
23218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23219 }
23220 arg4 = static_cast< int >(val4);
23221 }
23222 if (obj4) {
23223 ecode5 = SWIG_AsVal_int(obj4, &val5);
23224 if (!SWIG_IsOK(ecode5)) {
23225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23226 }
23227 arg5 = static_cast< int >(val5);
23228 }
23229 if (obj5) {
23230 ecode6 = SWIG_AsVal_int(obj5, &val6);
23231 if (!SWIG_IsOK(ecode6)) {
23232 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23233 }
23234 arg6 = static_cast< int >(val6);
23235 }
23236 if (obj6) {
23237 ecode7 = SWIG_AsVal_int(obj6, &val7);
23238 if (!SWIG_IsOK(ecode7)) {
23239 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23240 }
23241 arg7 = static_cast< int >(val7);
23242 }
23243 if (obj7) {
23244 ecode8 = SWIG_AsVal_int(obj7, &val8);
23245 if (!SWIG_IsOK(ecode8)) {
23246 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23247 }
23248 arg8 = static_cast< int >(val8);
23249 }
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 {
23253 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23254 result = (wxDateTime *) &_result_ref;
23255 }
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23267 PyObject *resultobj = 0;
23268 wxDateTime *arg1 = (wxDateTime *) 0 ;
23269 wxDateTime *result = 0 ;
23270 void *argp1 = 0 ;
23271 int res1 = 0 ;
23272 PyObject *swig_obj[1] ;
23273
23274 if (!args) SWIG_fail;
23275 swig_obj[0] = args;
23276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23277 if (!SWIG_IsOK(res1)) {
23278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23279 }
23280 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 {
23284 wxDateTime &_result_ref = (arg1)->ResetTime();
23285 result = (wxDateTime *) &_result_ref;
23286 }
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj = 0;
23299 wxDateTime *arg1 = (wxDateTime *) 0 ;
23300 int arg2 ;
23301 wxDateTime *result = 0 ;
23302 void *argp1 = 0 ;
23303 int res1 = 0 ;
23304 int val2 ;
23305 int ecode2 = 0 ;
23306 PyObject * obj0 = 0 ;
23307 PyObject * obj1 = 0 ;
23308 char * kwnames[] = {
23309 (char *) "self",(char *) "year", NULL
23310 };
23311
23312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23314 if (!SWIG_IsOK(res1)) {
23315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23316 }
23317 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23318 ecode2 = SWIG_AsVal_int(obj1, &val2);
23319 if (!SWIG_IsOK(ecode2)) {
23320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23321 }
23322 arg2 = static_cast< int >(val2);
23323 {
23324 PyThreadState* __tstate = wxPyBeginAllowThreads();
23325 {
23326 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23327 result = (wxDateTime *) &_result_ref;
23328 }
23329 wxPyEndAllowThreads(__tstate);
23330 if (PyErr_Occurred()) SWIG_fail;
23331 }
23332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj = 0;
23341 wxDateTime *arg1 = (wxDateTime *) 0 ;
23342 wxDateTime::Month arg2 ;
23343 wxDateTime *result = 0 ;
23344 void *argp1 = 0 ;
23345 int res1 = 0 ;
23346 int val2 ;
23347 int ecode2 = 0 ;
23348 PyObject * obj0 = 0 ;
23349 PyObject * obj1 = 0 ;
23350 char * kwnames[] = {
23351 (char *) "self",(char *) "month", NULL
23352 };
23353
23354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23356 if (!SWIG_IsOK(res1)) {
23357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23358 }
23359 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23360 ecode2 = SWIG_AsVal_int(obj1, &val2);
23361 if (!SWIG_IsOK(ecode2)) {
23362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23363 }
23364 arg2 = static_cast< wxDateTime::Month >(val2);
23365 {
23366 PyThreadState* __tstate = wxPyBeginAllowThreads();
23367 {
23368 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23369 result = (wxDateTime *) &_result_ref;
23370 }
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj = 0;
23383 wxDateTime *arg1 = (wxDateTime *) 0 ;
23384 int arg2 ;
23385 wxDateTime *result = 0 ;
23386 void *argp1 = 0 ;
23387 int res1 = 0 ;
23388 int val2 ;
23389 int ecode2 = 0 ;
23390 PyObject * obj0 = 0 ;
23391 PyObject * obj1 = 0 ;
23392 char * kwnames[] = {
23393 (char *) "self",(char *) "day", NULL
23394 };
23395
23396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23398 if (!SWIG_IsOK(res1)) {
23399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23400 }
23401 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23402 ecode2 = SWIG_AsVal_int(obj1, &val2);
23403 if (!SWIG_IsOK(ecode2)) {
23404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23405 }
23406 arg2 = static_cast< int >(val2);
23407 {
23408 PyThreadState* __tstate = wxPyBeginAllowThreads();
23409 {
23410 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23411 result = (wxDateTime *) &_result_ref;
23412 }
23413 wxPyEndAllowThreads(__tstate);
23414 if (PyErr_Occurred()) SWIG_fail;
23415 }
23416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23417 return resultobj;
23418 fail:
23419 return NULL;
23420 }
23421
23422
23423 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23424 PyObject *resultobj = 0;
23425 wxDateTime *arg1 = (wxDateTime *) 0 ;
23426 int arg2 ;
23427 wxDateTime *result = 0 ;
23428 void *argp1 = 0 ;
23429 int res1 = 0 ;
23430 int val2 ;
23431 int ecode2 = 0 ;
23432 PyObject * obj0 = 0 ;
23433 PyObject * obj1 = 0 ;
23434 char * kwnames[] = {
23435 (char *) "self",(char *) "hour", NULL
23436 };
23437
23438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23440 if (!SWIG_IsOK(res1)) {
23441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23442 }
23443 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23444 ecode2 = SWIG_AsVal_int(obj1, &val2);
23445 if (!SWIG_IsOK(ecode2)) {
23446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23447 }
23448 arg2 = static_cast< int >(val2);
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 {
23452 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23453 result = (wxDateTime *) &_result_ref;
23454 }
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23459 return resultobj;
23460 fail:
23461 return NULL;
23462 }
23463
23464
23465 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23466 PyObject *resultobj = 0;
23467 wxDateTime *arg1 = (wxDateTime *) 0 ;
23468 int arg2 ;
23469 wxDateTime *result = 0 ;
23470 void *argp1 = 0 ;
23471 int res1 = 0 ;
23472 int val2 ;
23473 int ecode2 = 0 ;
23474 PyObject * obj0 = 0 ;
23475 PyObject * obj1 = 0 ;
23476 char * kwnames[] = {
23477 (char *) "self",(char *) "minute", NULL
23478 };
23479
23480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23482 if (!SWIG_IsOK(res1)) {
23483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23484 }
23485 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23486 ecode2 = SWIG_AsVal_int(obj1, &val2);
23487 if (!SWIG_IsOK(ecode2)) {
23488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23489 }
23490 arg2 = static_cast< int >(val2);
23491 {
23492 PyThreadState* __tstate = wxPyBeginAllowThreads();
23493 {
23494 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23495 result = (wxDateTime *) &_result_ref;
23496 }
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj = 0;
23509 wxDateTime *arg1 = (wxDateTime *) 0 ;
23510 int arg2 ;
23511 wxDateTime *result = 0 ;
23512 void *argp1 = 0 ;
23513 int res1 = 0 ;
23514 int val2 ;
23515 int ecode2 = 0 ;
23516 PyObject * obj0 = 0 ;
23517 PyObject * obj1 = 0 ;
23518 char * kwnames[] = {
23519 (char *) "self",(char *) "second", NULL
23520 };
23521
23522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23524 if (!SWIG_IsOK(res1)) {
23525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23526 }
23527 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23528 ecode2 = SWIG_AsVal_int(obj1, &val2);
23529 if (!SWIG_IsOK(ecode2)) {
23530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23531 }
23532 arg2 = static_cast< int >(val2);
23533 {
23534 PyThreadState* __tstate = wxPyBeginAllowThreads();
23535 {
23536 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23537 result = (wxDateTime *) &_result_ref;
23538 }
23539 wxPyEndAllowThreads(__tstate);
23540 if (PyErr_Occurred()) SWIG_fail;
23541 }
23542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23543 return resultobj;
23544 fail:
23545 return NULL;
23546 }
23547
23548
23549 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23550 PyObject *resultobj = 0;
23551 wxDateTime *arg1 = (wxDateTime *) 0 ;
23552 int arg2 ;
23553 wxDateTime *result = 0 ;
23554 void *argp1 = 0 ;
23555 int res1 = 0 ;
23556 int val2 ;
23557 int ecode2 = 0 ;
23558 PyObject * obj0 = 0 ;
23559 PyObject * obj1 = 0 ;
23560 char * kwnames[] = {
23561 (char *) "self",(char *) "millisecond", NULL
23562 };
23563
23564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23566 if (!SWIG_IsOK(res1)) {
23567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23568 }
23569 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23570 ecode2 = SWIG_AsVal_int(obj1, &val2);
23571 if (!SWIG_IsOK(ecode2)) {
23572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23573 }
23574 arg2 = static_cast< int >(val2);
23575 {
23576 PyThreadState* __tstate = wxPyBeginAllowThreads();
23577 {
23578 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23579 result = (wxDateTime *) &_result_ref;
23580 }
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23592 PyObject *resultobj = 0;
23593 wxDateTime *arg1 = (wxDateTime *) 0 ;
23594 wxDateTime::WeekDay arg2 ;
23595 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23596 wxDateTime *result = 0 ;
23597 void *argp1 = 0 ;
23598 int res1 = 0 ;
23599 int val2 ;
23600 int ecode2 = 0 ;
23601 int val3 ;
23602 int ecode3 = 0 ;
23603 PyObject * obj0 = 0 ;
23604 PyObject * obj1 = 0 ;
23605 PyObject * obj2 = 0 ;
23606 char * kwnames[] = {
23607 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23608 };
23609
23610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23612 if (!SWIG_IsOK(res1)) {
23613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23614 }
23615 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23616 ecode2 = SWIG_AsVal_int(obj1, &val2);
23617 if (!SWIG_IsOK(ecode2)) {
23618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23619 }
23620 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23621 if (obj2) {
23622 ecode3 = SWIG_AsVal_int(obj2, &val3);
23623 if (!SWIG_IsOK(ecode3)) {
23624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23625 }
23626 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23627 }
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 {
23631 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23632 result = (wxDateTime *) &_result_ref;
23633 }
23634 wxPyEndAllowThreads(__tstate);
23635 if (PyErr_Occurred()) SWIG_fail;
23636 }
23637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23645 PyObject *resultobj = 0;
23646 wxDateTime *arg1 = (wxDateTime *) 0 ;
23647 wxDateTime::WeekDay arg2 ;
23648 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23649 wxDateTime result;
23650 void *argp1 = 0 ;
23651 int res1 = 0 ;
23652 int val2 ;
23653 int ecode2 = 0 ;
23654 int val3 ;
23655 int ecode3 = 0 ;
23656 PyObject * obj0 = 0 ;
23657 PyObject * obj1 = 0 ;
23658 PyObject * obj2 = 0 ;
23659 char * kwnames[] = {
23660 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23661 };
23662
23663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23665 if (!SWIG_IsOK(res1)) {
23666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23667 }
23668 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23669 ecode2 = SWIG_AsVal_int(obj1, &val2);
23670 if (!SWIG_IsOK(ecode2)) {
23671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23672 }
23673 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23674 if (obj2) {
23675 ecode3 = SWIG_AsVal_int(obj2, &val3);
23676 if (!SWIG_IsOK(ecode3)) {
23677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23678 }
23679 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23680 }
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23684 wxPyEndAllowThreads(__tstate);
23685 if (PyErr_Occurred()) SWIG_fail;
23686 }
23687 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23688 return resultobj;
23689 fail:
23690 return NULL;
23691 }
23692
23693
23694 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23695 PyObject *resultobj = 0;
23696 wxDateTime *arg1 = (wxDateTime *) 0 ;
23697 wxDateTime::WeekDay arg2 ;
23698 wxDateTime *result = 0 ;
23699 void *argp1 = 0 ;
23700 int res1 = 0 ;
23701 int val2 ;
23702 int ecode2 = 0 ;
23703 PyObject * obj0 = 0 ;
23704 PyObject * obj1 = 0 ;
23705 char * kwnames[] = {
23706 (char *) "self",(char *) "weekday", NULL
23707 };
23708
23709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23711 if (!SWIG_IsOK(res1)) {
23712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23713 }
23714 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23715 ecode2 = SWIG_AsVal_int(obj1, &val2);
23716 if (!SWIG_IsOK(ecode2)) {
23717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23718 }
23719 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 {
23723 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23724 result = (wxDateTime *) &_result_ref;
23725 }
23726 wxPyEndAllowThreads(__tstate);
23727 if (PyErr_Occurred()) SWIG_fail;
23728 }
23729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23730 return resultobj;
23731 fail:
23732 return NULL;
23733 }
23734
23735
23736 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23737 PyObject *resultobj = 0;
23738 wxDateTime *arg1 = (wxDateTime *) 0 ;
23739 wxDateTime::WeekDay arg2 ;
23740 wxDateTime result;
23741 void *argp1 = 0 ;
23742 int res1 = 0 ;
23743 int val2 ;
23744 int ecode2 = 0 ;
23745 PyObject * obj0 = 0 ;
23746 PyObject * obj1 = 0 ;
23747 char * kwnames[] = {
23748 (char *) "self",(char *) "weekday", NULL
23749 };
23750
23751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23753 if (!SWIG_IsOK(res1)) {
23754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23755 }
23756 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23757 ecode2 = SWIG_AsVal_int(obj1, &val2);
23758 if (!SWIG_IsOK(ecode2)) {
23759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23760 }
23761 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23762 {
23763 PyThreadState* __tstate = wxPyBeginAllowThreads();
23764 result = (arg1)->GetNextWeekDay(arg2);
23765 wxPyEndAllowThreads(__tstate);
23766 if (PyErr_Occurred()) SWIG_fail;
23767 }
23768 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23769 return resultobj;
23770 fail:
23771 return NULL;
23772 }
23773
23774
23775 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23776 PyObject *resultobj = 0;
23777 wxDateTime *arg1 = (wxDateTime *) 0 ;
23778 wxDateTime::WeekDay arg2 ;
23779 wxDateTime *result = 0 ;
23780 void *argp1 = 0 ;
23781 int res1 = 0 ;
23782 int val2 ;
23783 int ecode2 = 0 ;
23784 PyObject * obj0 = 0 ;
23785 PyObject * obj1 = 0 ;
23786 char * kwnames[] = {
23787 (char *) "self",(char *) "weekday", NULL
23788 };
23789
23790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23792 if (!SWIG_IsOK(res1)) {
23793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23794 }
23795 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23796 ecode2 = SWIG_AsVal_int(obj1, &val2);
23797 if (!SWIG_IsOK(ecode2)) {
23798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23799 }
23800 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23801 {
23802 PyThreadState* __tstate = wxPyBeginAllowThreads();
23803 {
23804 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23805 result = (wxDateTime *) &_result_ref;
23806 }
23807 wxPyEndAllowThreads(__tstate);
23808 if (PyErr_Occurred()) SWIG_fail;
23809 }
23810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23811 return resultobj;
23812 fail:
23813 return NULL;
23814 }
23815
23816
23817 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23818 PyObject *resultobj = 0;
23819 wxDateTime *arg1 = (wxDateTime *) 0 ;
23820 wxDateTime::WeekDay arg2 ;
23821 wxDateTime result;
23822 void *argp1 = 0 ;
23823 int res1 = 0 ;
23824 int val2 ;
23825 int ecode2 = 0 ;
23826 PyObject * obj0 = 0 ;
23827 PyObject * obj1 = 0 ;
23828 char * kwnames[] = {
23829 (char *) "self",(char *) "weekday", NULL
23830 };
23831
23832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23834 if (!SWIG_IsOK(res1)) {
23835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23836 }
23837 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23838 ecode2 = SWIG_AsVal_int(obj1, &val2);
23839 if (!SWIG_IsOK(ecode2)) {
23840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23841 }
23842 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23843 {
23844 PyThreadState* __tstate = wxPyBeginAllowThreads();
23845 result = (arg1)->GetPrevWeekDay(arg2);
23846 wxPyEndAllowThreads(__tstate);
23847 if (PyErr_Occurred()) SWIG_fail;
23848 }
23849 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj = 0;
23858 wxDateTime *arg1 = (wxDateTime *) 0 ;
23859 wxDateTime::WeekDay arg2 ;
23860 int arg3 = (int) 1 ;
23861 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23862 int arg5 = (int) wxDateTime::Inv_Year ;
23863 bool result;
23864 void *argp1 = 0 ;
23865 int res1 = 0 ;
23866 int val2 ;
23867 int ecode2 = 0 ;
23868 int val3 ;
23869 int ecode3 = 0 ;
23870 int val4 ;
23871 int ecode4 = 0 ;
23872 int val5 ;
23873 int ecode5 = 0 ;
23874 PyObject * obj0 = 0 ;
23875 PyObject * obj1 = 0 ;
23876 PyObject * obj2 = 0 ;
23877 PyObject * obj3 = 0 ;
23878 PyObject * obj4 = 0 ;
23879 char * kwnames[] = {
23880 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23881 };
23882
23883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23885 if (!SWIG_IsOK(res1)) {
23886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23887 }
23888 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23889 ecode2 = SWIG_AsVal_int(obj1, &val2);
23890 if (!SWIG_IsOK(ecode2)) {
23891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23892 }
23893 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23894 if (obj2) {
23895 ecode3 = SWIG_AsVal_int(obj2, &val3);
23896 if (!SWIG_IsOK(ecode3)) {
23897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23898 }
23899 arg3 = static_cast< int >(val3);
23900 }
23901 if (obj3) {
23902 ecode4 = SWIG_AsVal_int(obj3, &val4);
23903 if (!SWIG_IsOK(ecode4)) {
23904 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23905 }
23906 arg4 = static_cast< wxDateTime::Month >(val4);
23907 }
23908 if (obj4) {
23909 ecode5 = SWIG_AsVal_int(obj4, &val5);
23910 if (!SWIG_IsOK(ecode5)) {
23911 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23912 }
23913 arg5 = static_cast< int >(val5);
23914 }
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23918 wxPyEndAllowThreads(__tstate);
23919 if (PyErr_Occurred()) SWIG_fail;
23920 }
23921 {
23922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23923 }
23924 return resultobj;
23925 fail:
23926 return NULL;
23927 }
23928
23929
23930 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23931 PyObject *resultobj = 0;
23932 wxDateTime *arg1 = (wxDateTime *) 0 ;
23933 wxDateTime::WeekDay arg2 ;
23934 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23935 int arg4 = (int) wxDateTime::Inv_Year ;
23936 bool result;
23937 void *argp1 = 0 ;
23938 int res1 = 0 ;
23939 int val2 ;
23940 int ecode2 = 0 ;
23941 int val3 ;
23942 int ecode3 = 0 ;
23943 int val4 ;
23944 int ecode4 = 0 ;
23945 PyObject * obj0 = 0 ;
23946 PyObject * obj1 = 0 ;
23947 PyObject * obj2 = 0 ;
23948 PyObject * obj3 = 0 ;
23949 char * kwnames[] = {
23950 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23951 };
23952
23953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23955 if (!SWIG_IsOK(res1)) {
23956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23957 }
23958 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23959 ecode2 = SWIG_AsVal_int(obj1, &val2);
23960 if (!SWIG_IsOK(ecode2)) {
23961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23962 }
23963 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23964 if (obj2) {
23965 ecode3 = SWIG_AsVal_int(obj2, &val3);
23966 if (!SWIG_IsOK(ecode3)) {
23967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23968 }
23969 arg3 = static_cast< wxDateTime::Month >(val3);
23970 }
23971 if (obj3) {
23972 ecode4 = SWIG_AsVal_int(obj3, &val4);
23973 if (!SWIG_IsOK(ecode4)) {
23974 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23975 }
23976 arg4 = static_cast< int >(val4);
23977 }
23978 {
23979 PyThreadState* __tstate = wxPyBeginAllowThreads();
23980 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23981 wxPyEndAllowThreads(__tstate);
23982 if (PyErr_Occurred()) SWIG_fail;
23983 }
23984 {
23985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23986 }
23987 return resultobj;
23988 fail:
23989 return NULL;
23990 }
23991
23992
23993 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23994 PyObject *resultobj = 0;
23995 wxDateTime *arg1 = (wxDateTime *) 0 ;
23996 wxDateTime::WeekDay arg2 ;
23997 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23998 int arg4 = (int) wxDateTime::Inv_Year ;
23999 wxDateTime result;
24000 void *argp1 = 0 ;
24001 int res1 = 0 ;
24002 int val2 ;
24003 int ecode2 = 0 ;
24004 int val3 ;
24005 int ecode3 = 0 ;
24006 int val4 ;
24007 int ecode4 = 0 ;
24008 PyObject * obj0 = 0 ;
24009 PyObject * obj1 = 0 ;
24010 PyObject * obj2 = 0 ;
24011 PyObject * obj3 = 0 ;
24012 char * kwnames[] = {
24013 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24014 };
24015
24016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24018 if (!SWIG_IsOK(res1)) {
24019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24020 }
24021 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24022 ecode2 = SWIG_AsVal_int(obj1, &val2);
24023 if (!SWIG_IsOK(ecode2)) {
24024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24025 }
24026 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24027 if (obj2) {
24028 ecode3 = SWIG_AsVal_int(obj2, &val3);
24029 if (!SWIG_IsOK(ecode3)) {
24030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24031 }
24032 arg3 = static_cast< wxDateTime::Month >(val3);
24033 }
24034 if (obj3) {
24035 ecode4 = SWIG_AsVal_int(obj3, &val4);
24036 if (!SWIG_IsOK(ecode4)) {
24037 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24038 }
24039 arg4 = static_cast< int >(val4);
24040 }
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24044 wxPyEndAllowThreads(__tstate);
24045 if (PyErr_Occurred()) SWIG_fail;
24046 }
24047 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24048 return resultobj;
24049 fail:
24050 return NULL;
24051 }
24052
24053
24054 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24055 PyObject *resultobj = 0;
24056 wxDateTime *arg1 = (wxDateTime *) 0 ;
24057 int arg2 ;
24058 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24059 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24060 bool result;
24061 void *argp1 = 0 ;
24062 int res1 = 0 ;
24063 int val2 ;
24064 int ecode2 = 0 ;
24065 int val3 ;
24066 int ecode3 = 0 ;
24067 int val4 ;
24068 int ecode4 = 0 ;
24069 PyObject * obj0 = 0 ;
24070 PyObject * obj1 = 0 ;
24071 PyObject * obj2 = 0 ;
24072 PyObject * obj3 = 0 ;
24073 char * kwnames[] = {
24074 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24075 };
24076
24077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24079 if (!SWIG_IsOK(res1)) {
24080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24081 }
24082 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24083 ecode2 = SWIG_AsVal_int(obj1, &val2);
24084 if (!SWIG_IsOK(ecode2)) {
24085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24086 }
24087 arg2 = static_cast< int >(val2);
24088 if (obj2) {
24089 ecode3 = SWIG_AsVal_int(obj2, &val3);
24090 if (!SWIG_IsOK(ecode3)) {
24091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24092 }
24093 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24094 }
24095 if (obj3) {
24096 ecode4 = SWIG_AsVal_int(obj3, &val4);
24097 if (!SWIG_IsOK(ecode4)) {
24098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24099 }
24100 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24101 }
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 {
24109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24110 }
24111 return resultobj;
24112 fail:
24113 return NULL;
24114 }
24115
24116
24117 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24118 PyObject *resultobj = 0;
24119 wxDateTime *arg1 = (wxDateTime *) 0 ;
24120 int arg2 ;
24121 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24122 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24123 wxDateTime result;
24124 void *argp1 = 0 ;
24125 int res1 = 0 ;
24126 int val2 ;
24127 int ecode2 = 0 ;
24128 int val3 ;
24129 int ecode3 = 0 ;
24130 int val4 ;
24131 int ecode4 = 0 ;
24132 PyObject * obj0 = 0 ;
24133 PyObject * obj1 = 0 ;
24134 PyObject * obj2 = 0 ;
24135 PyObject * obj3 = 0 ;
24136 char * kwnames[] = {
24137 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24138 };
24139
24140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24142 if (!SWIG_IsOK(res1)) {
24143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24144 }
24145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24146 ecode2 = SWIG_AsVal_int(obj1, &val2);
24147 if (!SWIG_IsOK(ecode2)) {
24148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
24149 }
24150 arg2 = static_cast< int >(val2);
24151 if (obj2) {
24152 ecode3 = SWIG_AsVal_int(obj2, &val3);
24153 if (!SWIG_IsOK(ecode3)) {
24154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24155 }
24156 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24157 }
24158 if (obj3) {
24159 ecode4 = SWIG_AsVal_int(obj3, &val4);
24160 if (!SWIG_IsOK(ecode4)) {
24161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24162 }
24163 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24164 }
24165 {
24166 PyThreadState* __tstate = wxPyBeginAllowThreads();
24167 result = (arg1)->GetWeek(arg2,arg3,arg4);
24168 wxPyEndAllowThreads(__tstate);
24169 if (PyErr_Occurred()) SWIG_fail;
24170 }
24171 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24172 return resultobj;
24173 fail:
24174 return NULL;
24175 }
24176
24177
24178 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24179 PyObject *resultobj = 0;
24180 int arg1 ;
24181 int arg2 ;
24182 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24183 wxDateTime result;
24184 int val1 ;
24185 int ecode1 = 0 ;
24186 int val2 ;
24187 int ecode2 = 0 ;
24188 int val3 ;
24189 int ecode3 = 0 ;
24190 PyObject * obj0 = 0 ;
24191 PyObject * obj1 = 0 ;
24192 PyObject * obj2 = 0 ;
24193 char * kwnames[] = {
24194 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24195 };
24196
24197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24198 ecode1 = SWIG_AsVal_int(obj0, &val1);
24199 if (!SWIG_IsOK(ecode1)) {
24200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24201 }
24202 arg1 = static_cast< int >(val1);
24203 ecode2 = SWIG_AsVal_int(obj1, &val2);
24204 if (!SWIG_IsOK(ecode2)) {
24205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24206 }
24207 arg2 = static_cast< int >(val2);
24208 if (obj2) {
24209 ecode3 = SWIG_AsVal_int(obj2, &val3);
24210 if (!SWIG_IsOK(ecode3)) {
24211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24212 }
24213 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24214 }
24215 {
24216 PyThreadState* __tstate = wxPyBeginAllowThreads();
24217 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24218 wxPyEndAllowThreads(__tstate);
24219 if (PyErr_Occurred()) SWIG_fail;
24220 }
24221 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24229 PyObject *resultobj = 0;
24230 wxDateTime *arg1 = (wxDateTime *) 0 ;
24231 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24232 int arg3 = (int) wxDateTime::Inv_Year ;
24233 wxDateTime *result = 0 ;
24234 void *argp1 = 0 ;
24235 int res1 = 0 ;
24236 int val2 ;
24237 int ecode2 = 0 ;
24238 int val3 ;
24239 int ecode3 = 0 ;
24240 PyObject * obj0 = 0 ;
24241 PyObject * obj1 = 0 ;
24242 PyObject * obj2 = 0 ;
24243 char * kwnames[] = {
24244 (char *) "self",(char *) "month",(char *) "year", NULL
24245 };
24246
24247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24249 if (!SWIG_IsOK(res1)) {
24250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24251 }
24252 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24253 if (obj1) {
24254 ecode2 = SWIG_AsVal_int(obj1, &val2);
24255 if (!SWIG_IsOK(ecode2)) {
24256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24257 }
24258 arg2 = static_cast< wxDateTime::Month >(val2);
24259 }
24260 if (obj2) {
24261 ecode3 = SWIG_AsVal_int(obj2, &val3);
24262 if (!SWIG_IsOK(ecode3)) {
24263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24264 }
24265 arg3 = static_cast< int >(val3);
24266 }
24267 {
24268 PyThreadState* __tstate = wxPyBeginAllowThreads();
24269 {
24270 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24271 result = (wxDateTime *) &_result_ref;
24272 }
24273 wxPyEndAllowThreads(__tstate);
24274 if (PyErr_Occurred()) SWIG_fail;
24275 }
24276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24284 PyObject *resultobj = 0;
24285 wxDateTime *arg1 = (wxDateTime *) 0 ;
24286 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24287 int arg3 = (int) wxDateTime::Inv_Year ;
24288 wxDateTime result;
24289 void *argp1 = 0 ;
24290 int res1 = 0 ;
24291 int val2 ;
24292 int ecode2 = 0 ;
24293 int val3 ;
24294 int ecode3 = 0 ;
24295 PyObject * obj0 = 0 ;
24296 PyObject * obj1 = 0 ;
24297 PyObject * obj2 = 0 ;
24298 char * kwnames[] = {
24299 (char *) "self",(char *) "month",(char *) "year", NULL
24300 };
24301
24302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24304 if (!SWIG_IsOK(res1)) {
24305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24306 }
24307 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24308 if (obj1) {
24309 ecode2 = SWIG_AsVal_int(obj1, &val2);
24310 if (!SWIG_IsOK(ecode2)) {
24311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24312 }
24313 arg2 = static_cast< wxDateTime::Month >(val2);
24314 }
24315 if (obj2) {
24316 ecode3 = SWIG_AsVal_int(obj2, &val3);
24317 if (!SWIG_IsOK(ecode3)) {
24318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24319 }
24320 arg3 = static_cast< int >(val3);
24321 }
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 result = (arg1)->GetLastMonthDay(arg2,arg3);
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj = 0;
24337 wxDateTime *arg1 = (wxDateTime *) 0 ;
24338 int arg2 ;
24339 wxDateTime *result = 0 ;
24340 void *argp1 = 0 ;
24341 int res1 = 0 ;
24342 int val2 ;
24343 int ecode2 = 0 ;
24344 PyObject * obj0 = 0 ;
24345 PyObject * obj1 = 0 ;
24346 char * kwnames[] = {
24347 (char *) "self",(char *) "yday", NULL
24348 };
24349
24350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24352 if (!SWIG_IsOK(res1)) {
24353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24354 }
24355 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24356 ecode2 = SWIG_AsVal_int(obj1, &val2);
24357 if (!SWIG_IsOK(ecode2)) {
24358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24359 }
24360 arg2 = static_cast< int >(val2);
24361 {
24362 PyThreadState* __tstate = wxPyBeginAllowThreads();
24363 {
24364 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24365 result = (wxDateTime *) &_result_ref;
24366 }
24367 wxPyEndAllowThreads(__tstate);
24368 if (PyErr_Occurred()) SWIG_fail;
24369 }
24370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj = 0;
24379 wxDateTime *arg1 = (wxDateTime *) 0 ;
24380 int arg2 ;
24381 wxDateTime result;
24382 void *argp1 = 0 ;
24383 int res1 = 0 ;
24384 int val2 ;
24385 int ecode2 = 0 ;
24386 PyObject * obj0 = 0 ;
24387 PyObject * obj1 = 0 ;
24388 char * kwnames[] = {
24389 (char *) "self",(char *) "yday", NULL
24390 };
24391
24392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24394 if (!SWIG_IsOK(res1)) {
24395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24396 }
24397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24398 ecode2 = SWIG_AsVal_int(obj1, &val2);
24399 if (!SWIG_IsOK(ecode2)) {
24400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24401 }
24402 arg2 = static_cast< int >(val2);
24403 {
24404 PyThreadState* __tstate = wxPyBeginAllowThreads();
24405 result = (arg1)->GetYearDay(arg2);
24406 wxPyEndAllowThreads(__tstate);
24407 if (PyErr_Occurred()) SWIG_fail;
24408 }
24409 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24417 PyObject *resultobj = 0;
24418 wxDateTime *arg1 = (wxDateTime *) 0 ;
24419 double result;
24420 void *argp1 = 0 ;
24421 int res1 = 0 ;
24422 PyObject *swig_obj[1] ;
24423
24424 if (!args) SWIG_fail;
24425 swig_obj[0] = args;
24426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24427 if (!SWIG_IsOK(res1)) {
24428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24429 }
24430 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24431 {
24432 PyThreadState* __tstate = wxPyBeginAllowThreads();
24433 result = (double)(arg1)->GetJulianDayNumber();
24434 wxPyEndAllowThreads(__tstate);
24435 if (PyErr_Occurred()) SWIG_fail;
24436 }
24437 resultobj = SWIG_From_double(static_cast< double >(result));
24438 return resultobj;
24439 fail:
24440 return NULL;
24441 }
24442
24443
24444 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24445 PyObject *resultobj = 0;
24446 wxDateTime *arg1 = (wxDateTime *) 0 ;
24447 double result;
24448 void *argp1 = 0 ;
24449 int res1 = 0 ;
24450 PyObject *swig_obj[1] ;
24451
24452 if (!args) SWIG_fail;
24453 swig_obj[0] = args;
24454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24455 if (!SWIG_IsOK(res1)) {
24456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24457 }
24458 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24459 {
24460 PyThreadState* __tstate = wxPyBeginAllowThreads();
24461 result = (double)(arg1)->GetJDN();
24462 wxPyEndAllowThreads(__tstate);
24463 if (PyErr_Occurred()) SWIG_fail;
24464 }
24465 resultobj = SWIG_From_double(static_cast< double >(result));
24466 return resultobj;
24467 fail:
24468 return NULL;
24469 }
24470
24471
24472 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24473 PyObject *resultobj = 0;
24474 wxDateTime *arg1 = (wxDateTime *) 0 ;
24475 double result;
24476 void *argp1 = 0 ;
24477 int res1 = 0 ;
24478 PyObject *swig_obj[1] ;
24479
24480 if (!args) SWIG_fail;
24481 swig_obj[0] = args;
24482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24483 if (!SWIG_IsOK(res1)) {
24484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24485 }
24486 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24487 {
24488 PyThreadState* __tstate = wxPyBeginAllowThreads();
24489 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24490 wxPyEndAllowThreads(__tstate);
24491 if (PyErr_Occurred()) SWIG_fail;
24492 }
24493 resultobj = SWIG_From_double(static_cast< double >(result));
24494 return resultobj;
24495 fail:
24496 return NULL;
24497 }
24498
24499
24500 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24501 PyObject *resultobj = 0;
24502 wxDateTime *arg1 = (wxDateTime *) 0 ;
24503 double result;
24504 void *argp1 = 0 ;
24505 int res1 = 0 ;
24506 PyObject *swig_obj[1] ;
24507
24508 if (!args) SWIG_fail;
24509 swig_obj[0] = args;
24510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24511 if (!SWIG_IsOK(res1)) {
24512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24513 }
24514 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24515 {
24516 PyThreadState* __tstate = wxPyBeginAllowThreads();
24517 result = (double)(arg1)->GetMJD();
24518 wxPyEndAllowThreads(__tstate);
24519 if (PyErr_Occurred()) SWIG_fail;
24520 }
24521 resultobj = SWIG_From_double(static_cast< double >(result));
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *resultobj = 0;
24530 wxDateTime *arg1 = (wxDateTime *) 0 ;
24531 double result;
24532 void *argp1 = 0 ;
24533 int res1 = 0 ;
24534 PyObject *swig_obj[1] ;
24535
24536 if (!args) SWIG_fail;
24537 swig_obj[0] = args;
24538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24539 if (!SWIG_IsOK(res1)) {
24540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24541 }
24542 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24543 {
24544 PyThreadState* __tstate = wxPyBeginAllowThreads();
24545 result = (double)(arg1)->GetRataDie();
24546 wxPyEndAllowThreads(__tstate);
24547 if (PyErr_Occurred()) SWIG_fail;
24548 }
24549 resultobj = SWIG_From_double(static_cast< double >(result));
24550 return resultobj;
24551 fail:
24552 return NULL;
24553 }
24554
24555
24556 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24557 PyObject *resultobj = 0;
24558 wxDateTime *arg1 = (wxDateTime *) 0 ;
24559 wxDateTime::TimeZone *arg2 = 0 ;
24560 bool arg3 = (bool) false ;
24561 wxDateTime result;
24562 void *argp1 = 0 ;
24563 int res1 = 0 ;
24564 bool temp2 = false ;
24565 bool val3 ;
24566 int ecode3 = 0 ;
24567 PyObject * obj0 = 0 ;
24568 PyObject * obj1 = 0 ;
24569 PyObject * obj2 = 0 ;
24570 char * kwnames[] = {
24571 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24572 };
24573
24574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24576 if (!SWIG_IsOK(res1)) {
24577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24578 }
24579 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24580 {
24581 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24582 temp2 = true;
24583 }
24584 if (obj2) {
24585 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24586 if (!SWIG_IsOK(ecode3)) {
24587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24588 }
24589 arg3 = static_cast< bool >(val3);
24590 }
24591 {
24592 PyThreadState* __tstate = wxPyBeginAllowThreads();
24593 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24598 {
24599 if (temp2) delete arg2;
24600 }
24601 return resultobj;
24602 fail:
24603 {
24604 if (temp2) delete arg2;
24605 }
24606 return NULL;
24607 }
24608
24609
24610 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj = 0;
24612 wxDateTime *arg1 = (wxDateTime *) 0 ;
24613 wxDateTime::TimeZone *arg2 = 0 ;
24614 bool arg3 = (bool) false ;
24615 wxDateTime *result = 0 ;
24616 void *argp1 = 0 ;
24617 int res1 = 0 ;
24618 bool temp2 = false ;
24619 bool val3 ;
24620 int ecode3 = 0 ;
24621 PyObject * obj0 = 0 ;
24622 PyObject * obj1 = 0 ;
24623 PyObject * obj2 = 0 ;
24624 char * kwnames[] = {
24625 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24626 };
24627
24628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24630 if (!SWIG_IsOK(res1)) {
24631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24632 }
24633 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24634 {
24635 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24636 temp2 = true;
24637 }
24638 if (obj2) {
24639 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24640 if (!SWIG_IsOK(ecode3)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24642 }
24643 arg3 = static_cast< bool >(val3);
24644 }
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 {
24648 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24649 result = (wxDateTime *) &_result_ref;
24650 }
24651 wxPyEndAllowThreads(__tstate);
24652 if (PyErr_Occurred()) SWIG_fail;
24653 }
24654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24655 {
24656 if (temp2) delete arg2;
24657 }
24658 return resultobj;
24659 fail:
24660 {
24661 if (temp2) delete arg2;
24662 }
24663 return NULL;
24664 }
24665
24666
24667 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24668 PyObject *resultobj = 0;
24669 wxDateTime *arg1 = (wxDateTime *) 0 ;
24670 wxDateTime::TimeZone *arg2 = 0 ;
24671 bool arg3 = (bool) false ;
24672 wxDateTime result;
24673 void *argp1 = 0 ;
24674 int res1 = 0 ;
24675 bool temp2 = false ;
24676 bool val3 ;
24677 int ecode3 = 0 ;
24678 PyObject * obj0 = 0 ;
24679 PyObject * obj1 = 0 ;
24680 PyObject * obj2 = 0 ;
24681 char * kwnames[] = {
24682 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24683 };
24684
24685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24687 if (!SWIG_IsOK(res1)) {
24688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24689 }
24690 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24691 {
24692 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24693 temp2 = true;
24694 }
24695 if (obj2) {
24696 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24697 if (!SWIG_IsOK(ecode3)) {
24698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24699 }
24700 arg3 = static_cast< bool >(val3);
24701 }
24702 {
24703 PyThreadState* __tstate = wxPyBeginAllowThreads();
24704 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24705 wxPyEndAllowThreads(__tstate);
24706 if (PyErr_Occurred()) SWIG_fail;
24707 }
24708 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24709 {
24710 if (temp2) delete arg2;
24711 }
24712 return resultobj;
24713 fail:
24714 {
24715 if (temp2) delete arg2;
24716 }
24717 return NULL;
24718 }
24719
24720
24721 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24722 PyObject *resultobj = 0;
24723 wxDateTime *arg1 = (wxDateTime *) 0 ;
24724 wxDateTime::TimeZone *arg2 = 0 ;
24725 bool arg3 = (bool) false ;
24726 wxDateTime *result = 0 ;
24727 void *argp1 = 0 ;
24728 int res1 = 0 ;
24729 bool temp2 = false ;
24730 bool val3 ;
24731 int ecode3 = 0 ;
24732 PyObject * obj0 = 0 ;
24733 PyObject * obj1 = 0 ;
24734 PyObject * obj2 = 0 ;
24735 char * kwnames[] = {
24736 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24737 };
24738
24739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24741 if (!SWIG_IsOK(res1)) {
24742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24743 }
24744 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24745 {
24746 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24747 temp2 = true;
24748 }
24749 if (obj2) {
24750 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24751 if (!SWIG_IsOK(ecode3)) {
24752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24753 }
24754 arg3 = static_cast< bool >(val3);
24755 }
24756 {
24757 PyThreadState* __tstate = wxPyBeginAllowThreads();
24758 {
24759 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24760 result = (wxDateTime *) &_result_ref;
24761 }
24762 wxPyEndAllowThreads(__tstate);
24763 if (PyErr_Occurred()) SWIG_fail;
24764 }
24765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24766 {
24767 if (temp2) delete arg2;
24768 }
24769 return resultobj;
24770 fail:
24771 {
24772 if (temp2) delete arg2;
24773 }
24774 return NULL;
24775 }
24776
24777
24778 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24779 PyObject *resultobj = 0;
24780 wxDateTime *arg1 = (wxDateTime *) 0 ;
24781 bool arg2 = (bool) false ;
24782 wxDateTime result;
24783 void *argp1 = 0 ;
24784 int res1 = 0 ;
24785 bool val2 ;
24786 int ecode2 = 0 ;
24787 PyObject * obj0 = 0 ;
24788 PyObject * obj1 = 0 ;
24789 char * kwnames[] = {
24790 (char *) "self",(char *) "noDST", NULL
24791 };
24792
24793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24795 if (!SWIG_IsOK(res1)) {
24796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24797 }
24798 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24799 if (obj1) {
24800 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24801 if (!SWIG_IsOK(ecode2)) {
24802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24803 }
24804 arg2 = static_cast< bool >(val2);
24805 }
24806 {
24807 PyThreadState* __tstate = wxPyBeginAllowThreads();
24808 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24809 wxPyEndAllowThreads(__tstate);
24810 if (PyErr_Occurred()) SWIG_fail;
24811 }
24812 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24820 PyObject *resultobj = 0;
24821 wxDateTime *arg1 = (wxDateTime *) 0 ;
24822 bool arg2 = (bool) false ;
24823 wxDateTime *result = 0 ;
24824 void *argp1 = 0 ;
24825 int res1 = 0 ;
24826 bool val2 ;
24827 int ecode2 = 0 ;
24828 PyObject * obj0 = 0 ;
24829 PyObject * obj1 = 0 ;
24830 char * kwnames[] = {
24831 (char *) "self",(char *) "noDST", NULL
24832 };
24833
24834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24836 if (!SWIG_IsOK(res1)) {
24837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24838 }
24839 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24840 if (obj1) {
24841 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24842 if (!SWIG_IsOK(ecode2)) {
24843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24844 }
24845 arg2 = static_cast< bool >(val2);
24846 }
24847 {
24848 PyThreadState* __tstate = wxPyBeginAllowThreads();
24849 {
24850 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24851 result = (wxDateTime *) &_result_ref;
24852 }
24853 wxPyEndAllowThreads(__tstate);
24854 if (PyErr_Occurred()) SWIG_fail;
24855 }
24856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24864 PyObject *resultobj = 0;
24865 wxDateTime *arg1 = (wxDateTime *) 0 ;
24866 bool arg2 = (bool) false ;
24867 wxDateTime result;
24868 void *argp1 = 0 ;
24869 int res1 = 0 ;
24870 bool val2 ;
24871 int ecode2 = 0 ;
24872 PyObject * obj0 = 0 ;
24873 PyObject * obj1 = 0 ;
24874 char * kwnames[] = {
24875 (char *) "self",(char *) "noDST", NULL
24876 };
24877
24878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24880 if (!SWIG_IsOK(res1)) {
24881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24882 }
24883 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24884 if (obj1) {
24885 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24886 if (!SWIG_IsOK(ecode2)) {
24887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24888 }
24889 arg2 = static_cast< bool >(val2);
24890 }
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24905 PyObject *resultobj = 0;
24906 wxDateTime *arg1 = (wxDateTime *) 0 ;
24907 bool arg2 = (bool) false ;
24908 wxDateTime *result = 0 ;
24909 void *argp1 = 0 ;
24910 int res1 = 0 ;
24911 bool val2 ;
24912 int ecode2 = 0 ;
24913 PyObject * obj0 = 0 ;
24914 PyObject * obj1 = 0 ;
24915 char * kwnames[] = {
24916 (char *) "self",(char *) "noDST", NULL
24917 };
24918
24919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24921 if (!SWIG_IsOK(res1)) {
24922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24923 }
24924 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24925 if (obj1) {
24926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24927 if (!SWIG_IsOK(ecode2)) {
24928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24929 }
24930 arg2 = static_cast< bool >(val2);
24931 }
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 {
24935 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24936 result = (wxDateTime *) &_result_ref;
24937 }
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24942 return resultobj;
24943 fail:
24944 return NULL;
24945 }
24946
24947
24948 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24949 PyObject *resultobj = 0;
24950 wxDateTime *arg1 = (wxDateTime *) 0 ;
24951 bool arg2 = (bool) false ;
24952 wxDateTime result;
24953 void *argp1 = 0 ;
24954 int res1 = 0 ;
24955 bool val2 ;
24956 int ecode2 = 0 ;
24957 PyObject * obj0 = 0 ;
24958 PyObject * obj1 = 0 ;
24959 char * kwnames[] = {
24960 (char *) "self",(char *) "noDST", NULL
24961 };
24962
24963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24965 if (!SWIG_IsOK(res1)) {
24966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24967 }
24968 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24969 if (obj1) {
24970 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24971 if (!SWIG_IsOK(ecode2)) {
24972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24973 }
24974 arg2 = static_cast< bool >(val2);
24975 }
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24990 PyObject *resultobj = 0;
24991 wxDateTime *arg1 = (wxDateTime *) 0 ;
24992 bool arg2 = (bool) false ;
24993 wxDateTime *result = 0 ;
24994 void *argp1 = 0 ;
24995 int res1 = 0 ;
24996 bool val2 ;
24997 int ecode2 = 0 ;
24998 PyObject * obj0 = 0 ;
24999 PyObject * obj1 = 0 ;
25000 char * kwnames[] = {
25001 (char *) "self",(char *) "noDST", NULL
25002 };
25003
25004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25006 if (!SWIG_IsOK(res1)) {
25007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25008 }
25009 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25010 if (obj1) {
25011 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25012 if (!SWIG_IsOK(ecode2)) {
25013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25014 }
25015 arg2 = static_cast< bool >(val2);
25016 }
25017 {
25018 PyThreadState* __tstate = wxPyBeginAllowThreads();
25019 {
25020 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25021 result = (wxDateTime *) &_result_ref;
25022 }
25023 wxPyEndAllowThreads(__tstate);
25024 if (PyErr_Occurred()) SWIG_fail;
25025 }
25026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25034 PyObject *resultobj = 0;
25035 wxDateTime *arg1 = (wxDateTime *) 0 ;
25036 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25037 int result;
25038 void *argp1 = 0 ;
25039 int res1 = 0 ;
25040 int val2 ;
25041 int ecode2 = 0 ;
25042 PyObject * obj0 = 0 ;
25043 PyObject * obj1 = 0 ;
25044 char * kwnames[] = {
25045 (char *) "self",(char *) "country", NULL
25046 };
25047
25048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25050 if (!SWIG_IsOK(res1)) {
25051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
25052 }
25053 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25054 if (obj1) {
25055 ecode2 = SWIG_AsVal_int(obj1, &val2);
25056 if (!SWIG_IsOK(ecode2)) {
25057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25058 }
25059 arg2 = static_cast< wxDateTime::Country >(val2);
25060 }
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = (int)(arg1)->IsDST(arg2);
25064 wxPyEndAllowThreads(__tstate);
25065 if (PyErr_Occurred()) SWIG_fail;
25066 }
25067 resultobj = SWIG_From_int(static_cast< int >(result));
25068 return resultobj;
25069 fail:
25070 return NULL;
25071 }
25072
25073
25074 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25075 PyObject *resultobj = 0;
25076 wxDateTime *arg1 = (wxDateTime *) 0 ;
25077 bool result;
25078 void *argp1 = 0 ;
25079 int res1 = 0 ;
25080 PyObject *swig_obj[1] ;
25081
25082 if (!args) SWIG_fail;
25083 swig_obj[0] = args;
25084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25085 if (!SWIG_IsOK(res1)) {
25086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25087 }
25088 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 result = (bool)((wxDateTime const *)arg1)->IsValid();
25092 wxPyEndAllowThreads(__tstate);
25093 if (PyErr_Occurred()) SWIG_fail;
25094 }
25095 {
25096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25097 }
25098 return resultobj;
25099 fail:
25100 return NULL;
25101 }
25102
25103
25104 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25105 PyObject *resultobj = 0;
25106 wxDateTime *arg1 = (wxDateTime *) 0 ;
25107 time_t result;
25108 void *argp1 = 0 ;
25109 int res1 = 0 ;
25110 PyObject *swig_obj[1] ;
25111
25112 if (!args) SWIG_fail;
25113 swig_obj[0] = args;
25114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25115 if (!SWIG_IsOK(res1)) {
25116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25117 }
25118 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25119 {
25120 PyThreadState* __tstate = wxPyBeginAllowThreads();
25121 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
25122 wxPyEndAllowThreads(__tstate);
25123 if (PyErr_Occurred()) SWIG_fail;
25124 }
25125 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25126 return resultobj;
25127 fail:
25128 return NULL;
25129 }
25130
25131
25132 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25133 PyObject *resultobj = 0;
25134 wxDateTime *arg1 = (wxDateTime *) 0 ;
25135 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25136 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25137 int result;
25138 void *argp1 = 0 ;
25139 int res1 = 0 ;
25140 bool temp2 = false ;
25141 PyObject * obj0 = 0 ;
25142 PyObject * obj1 = 0 ;
25143 char * kwnames[] = {
25144 (char *) "self",(char *) "tz", NULL
25145 };
25146
25147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
25148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25149 if (!SWIG_IsOK(res1)) {
25150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25151 }
25152 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25153 if (obj1) {
25154 {
25155 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25156 temp2 = true;
25157 }
25158 }
25159 {
25160 PyThreadState* __tstate = wxPyBeginAllowThreads();
25161 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
25162 wxPyEndAllowThreads(__tstate);
25163 if (PyErr_Occurred()) SWIG_fail;
25164 }
25165 resultobj = SWIG_From_int(static_cast< int >(result));
25166 {
25167 if (temp2) delete arg2;
25168 }
25169 return resultobj;
25170 fail:
25171 {
25172 if (temp2) delete arg2;
25173 }
25174 return NULL;
25175 }
25176
25177
25178 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25179 PyObject *resultobj = 0;
25180 wxDateTime *arg1 = (wxDateTime *) 0 ;
25181 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25182 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25183 wxDateTime::Month result;
25184 void *argp1 = 0 ;
25185 int res1 = 0 ;
25186 bool temp2 = false ;
25187 PyObject * obj0 = 0 ;
25188 PyObject * obj1 = 0 ;
25189 char * kwnames[] = {
25190 (char *) "self",(char *) "tz", NULL
25191 };
25192
25193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25195 if (!SWIG_IsOK(res1)) {
25196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25197 }
25198 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25199 if (obj1) {
25200 {
25201 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25202 temp2 = true;
25203 }
25204 }
25205 {
25206 PyThreadState* __tstate = wxPyBeginAllowThreads();
25207 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25208 wxPyEndAllowThreads(__tstate);
25209 if (PyErr_Occurred()) SWIG_fail;
25210 }
25211 resultobj = SWIG_From_int(static_cast< int >(result));
25212 {
25213 if (temp2) delete arg2;
25214 }
25215 return resultobj;
25216 fail:
25217 {
25218 if (temp2) delete arg2;
25219 }
25220 return NULL;
25221 }
25222
25223
25224 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj = 0;
25226 wxDateTime *arg1 = (wxDateTime *) 0 ;
25227 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25228 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25229 int result;
25230 void *argp1 = 0 ;
25231 int res1 = 0 ;
25232 bool temp2 = false ;
25233 PyObject * obj0 = 0 ;
25234 PyObject * obj1 = 0 ;
25235 char * kwnames[] = {
25236 (char *) "self",(char *) "tz", NULL
25237 };
25238
25239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25241 if (!SWIG_IsOK(res1)) {
25242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25243 }
25244 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25245 if (obj1) {
25246 {
25247 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25248 temp2 = true;
25249 }
25250 }
25251 {
25252 PyThreadState* __tstate = wxPyBeginAllowThreads();
25253 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25254 wxPyEndAllowThreads(__tstate);
25255 if (PyErr_Occurred()) SWIG_fail;
25256 }
25257 resultobj = SWIG_From_int(static_cast< int >(result));
25258 {
25259 if (temp2) delete arg2;
25260 }
25261 return resultobj;
25262 fail:
25263 {
25264 if (temp2) delete arg2;
25265 }
25266 return NULL;
25267 }
25268
25269
25270 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25271 PyObject *resultobj = 0;
25272 wxDateTime *arg1 = (wxDateTime *) 0 ;
25273 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25274 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25275 wxDateTime::WeekDay result;
25276 void *argp1 = 0 ;
25277 int res1 = 0 ;
25278 bool temp2 = false ;
25279 PyObject * obj0 = 0 ;
25280 PyObject * obj1 = 0 ;
25281 char * kwnames[] = {
25282 (char *) "self",(char *) "tz", NULL
25283 };
25284
25285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25287 if (!SWIG_IsOK(res1)) {
25288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25289 }
25290 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25291 if (obj1) {
25292 {
25293 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25294 temp2 = true;
25295 }
25296 }
25297 {
25298 PyThreadState* __tstate = wxPyBeginAllowThreads();
25299 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25300 wxPyEndAllowThreads(__tstate);
25301 if (PyErr_Occurred()) SWIG_fail;
25302 }
25303 resultobj = SWIG_From_int(static_cast< int >(result));
25304 {
25305 if (temp2) delete arg2;
25306 }
25307 return resultobj;
25308 fail:
25309 {
25310 if (temp2) delete arg2;
25311 }
25312 return NULL;
25313 }
25314
25315
25316 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25317 PyObject *resultobj = 0;
25318 wxDateTime *arg1 = (wxDateTime *) 0 ;
25319 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25320 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25321 int result;
25322 void *argp1 = 0 ;
25323 int res1 = 0 ;
25324 bool temp2 = false ;
25325 PyObject * obj0 = 0 ;
25326 PyObject * obj1 = 0 ;
25327 char * kwnames[] = {
25328 (char *) "self",(char *) "tz", NULL
25329 };
25330
25331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25333 if (!SWIG_IsOK(res1)) {
25334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25335 }
25336 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25337 if (obj1) {
25338 {
25339 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25340 temp2 = true;
25341 }
25342 }
25343 {
25344 PyThreadState* __tstate = wxPyBeginAllowThreads();
25345 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25346 wxPyEndAllowThreads(__tstate);
25347 if (PyErr_Occurred()) SWIG_fail;
25348 }
25349 resultobj = SWIG_From_int(static_cast< int >(result));
25350 {
25351 if (temp2) delete arg2;
25352 }
25353 return resultobj;
25354 fail:
25355 {
25356 if (temp2) delete arg2;
25357 }
25358 return NULL;
25359 }
25360
25361
25362 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25363 PyObject *resultobj = 0;
25364 wxDateTime *arg1 = (wxDateTime *) 0 ;
25365 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25366 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25367 int result;
25368 void *argp1 = 0 ;
25369 int res1 = 0 ;
25370 bool temp2 = false ;
25371 PyObject * obj0 = 0 ;
25372 PyObject * obj1 = 0 ;
25373 char * kwnames[] = {
25374 (char *) "self",(char *) "tz", NULL
25375 };
25376
25377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25379 if (!SWIG_IsOK(res1)) {
25380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25381 }
25382 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25383 if (obj1) {
25384 {
25385 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25386 temp2 = true;
25387 }
25388 }
25389 {
25390 PyThreadState* __tstate = wxPyBeginAllowThreads();
25391 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25392 wxPyEndAllowThreads(__tstate);
25393 if (PyErr_Occurred()) SWIG_fail;
25394 }
25395 resultobj = SWIG_From_int(static_cast< int >(result));
25396 {
25397 if (temp2) delete arg2;
25398 }
25399 return resultobj;
25400 fail:
25401 {
25402 if (temp2) delete arg2;
25403 }
25404 return NULL;
25405 }
25406
25407
25408 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25409 PyObject *resultobj = 0;
25410 wxDateTime *arg1 = (wxDateTime *) 0 ;
25411 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25412 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25413 int result;
25414 void *argp1 = 0 ;
25415 int res1 = 0 ;
25416 bool temp2 = false ;
25417 PyObject * obj0 = 0 ;
25418 PyObject * obj1 = 0 ;
25419 char * kwnames[] = {
25420 (char *) "self",(char *) "tz", NULL
25421 };
25422
25423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25425 if (!SWIG_IsOK(res1)) {
25426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25427 }
25428 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25429 if (obj1) {
25430 {
25431 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25432 temp2 = true;
25433 }
25434 }
25435 {
25436 PyThreadState* __tstate = wxPyBeginAllowThreads();
25437 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25438 wxPyEndAllowThreads(__tstate);
25439 if (PyErr_Occurred()) SWIG_fail;
25440 }
25441 resultobj = SWIG_From_int(static_cast< int >(result));
25442 {
25443 if (temp2) delete arg2;
25444 }
25445 return resultobj;
25446 fail:
25447 {
25448 if (temp2) delete arg2;
25449 }
25450 return NULL;
25451 }
25452
25453
25454 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25455 PyObject *resultobj = 0;
25456 wxDateTime *arg1 = (wxDateTime *) 0 ;
25457 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25458 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25459 int result;
25460 void *argp1 = 0 ;
25461 int res1 = 0 ;
25462 bool temp2 = false ;
25463 PyObject * obj0 = 0 ;
25464 PyObject * obj1 = 0 ;
25465 char * kwnames[] = {
25466 (char *) "self",(char *) "tz", NULL
25467 };
25468
25469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25471 if (!SWIG_IsOK(res1)) {
25472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25473 }
25474 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25475 if (obj1) {
25476 {
25477 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25478 temp2 = true;
25479 }
25480 }
25481 {
25482 PyThreadState* __tstate = wxPyBeginAllowThreads();
25483 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25484 wxPyEndAllowThreads(__tstate);
25485 if (PyErr_Occurred()) SWIG_fail;
25486 }
25487 resultobj = SWIG_From_int(static_cast< int >(result));
25488 {
25489 if (temp2) delete arg2;
25490 }
25491 return resultobj;
25492 fail:
25493 {
25494 if (temp2) delete arg2;
25495 }
25496 return NULL;
25497 }
25498
25499
25500 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25501 PyObject *resultobj = 0;
25502 wxDateTime *arg1 = (wxDateTime *) 0 ;
25503 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25504 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25505 int result;
25506 void *argp1 = 0 ;
25507 int res1 = 0 ;
25508 bool temp2 = false ;
25509 PyObject * obj0 = 0 ;
25510 PyObject * obj1 = 0 ;
25511 char * kwnames[] = {
25512 (char *) "self",(char *) "tz", NULL
25513 };
25514
25515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25517 if (!SWIG_IsOK(res1)) {
25518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25519 }
25520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25521 if (obj1) {
25522 {
25523 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25524 temp2 = true;
25525 }
25526 }
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 resultobj = SWIG_From_int(static_cast< int >(result));
25534 {
25535 if (temp2) delete arg2;
25536 }
25537 return resultobj;
25538 fail:
25539 {
25540 if (temp2) delete arg2;
25541 }
25542 return NULL;
25543 }
25544
25545
25546 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj = 0;
25548 wxDateTime *arg1 = (wxDateTime *) 0 ;
25549 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25550 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25551 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25552 int result;
25553 void *argp1 = 0 ;
25554 int res1 = 0 ;
25555 int val2 ;
25556 int ecode2 = 0 ;
25557 bool temp3 = false ;
25558 PyObject * obj0 = 0 ;
25559 PyObject * obj1 = 0 ;
25560 PyObject * obj2 = 0 ;
25561 char * kwnames[] = {
25562 (char *) "self",(char *) "flags",(char *) "tz", NULL
25563 };
25564
25565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25567 if (!SWIG_IsOK(res1)) {
25568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25569 }
25570 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25571 if (obj1) {
25572 ecode2 = SWIG_AsVal_int(obj1, &val2);
25573 if (!SWIG_IsOK(ecode2)) {
25574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25575 }
25576 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25577 }
25578 if (obj2) {
25579 {
25580 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25581 temp3 = true;
25582 }
25583 }
25584 {
25585 PyThreadState* __tstate = wxPyBeginAllowThreads();
25586 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25587 wxPyEndAllowThreads(__tstate);
25588 if (PyErr_Occurred()) SWIG_fail;
25589 }
25590 resultobj = SWIG_From_int(static_cast< int >(result));
25591 {
25592 if (temp3) delete arg3;
25593 }
25594 return resultobj;
25595 fail:
25596 {
25597 if (temp3) delete arg3;
25598 }
25599 return NULL;
25600 }
25601
25602
25603 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25604 PyObject *resultobj = 0;
25605 wxDateTime *arg1 = (wxDateTime *) 0 ;
25606 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25607 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25608 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25609 int result;
25610 void *argp1 = 0 ;
25611 int res1 = 0 ;
25612 int val2 ;
25613 int ecode2 = 0 ;
25614 bool temp3 = false ;
25615 PyObject * obj0 = 0 ;
25616 PyObject * obj1 = 0 ;
25617 PyObject * obj2 = 0 ;
25618 char * kwnames[] = {
25619 (char *) "self",(char *) "flags",(char *) "tz", NULL
25620 };
25621
25622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25624 if (!SWIG_IsOK(res1)) {
25625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25626 }
25627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25628 if (obj1) {
25629 ecode2 = SWIG_AsVal_int(obj1, &val2);
25630 if (!SWIG_IsOK(ecode2)) {
25631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25632 }
25633 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25634 }
25635 if (obj2) {
25636 {
25637 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25638 temp3 = true;
25639 }
25640 }
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 resultobj = SWIG_From_int(static_cast< int >(result));
25648 {
25649 if (temp3) delete arg3;
25650 }
25651 return resultobj;
25652 fail:
25653 {
25654 if (temp3) delete arg3;
25655 }
25656 return NULL;
25657 }
25658
25659
25660 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25661 PyObject *resultobj = 0;
25662 wxDateTime *arg1 = (wxDateTime *) 0 ;
25663 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25664 bool result;
25665 void *argp1 = 0 ;
25666 int res1 = 0 ;
25667 int val2 ;
25668 int ecode2 = 0 ;
25669 PyObject * obj0 = 0 ;
25670 PyObject * obj1 = 0 ;
25671 char * kwnames[] = {
25672 (char *) "self",(char *) "country", NULL
25673 };
25674
25675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25677 if (!SWIG_IsOK(res1)) {
25678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25679 }
25680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25681 if (obj1) {
25682 ecode2 = SWIG_AsVal_int(obj1, &val2);
25683 if (!SWIG_IsOK(ecode2)) {
25684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25685 }
25686 arg2 = static_cast< wxDateTime::Country >(val2);
25687 }
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 {
25695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25696 }
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25704 PyObject *resultobj = 0;
25705 wxDateTime *arg1 = (wxDateTime *) 0 ;
25706 wxDateTime *arg2 = 0 ;
25707 bool result;
25708 void *argp1 = 0 ;
25709 int res1 = 0 ;
25710 void *argp2 = 0 ;
25711 int res2 = 0 ;
25712 PyObject * obj0 = 0 ;
25713 PyObject * obj1 = 0 ;
25714 char * kwnames[] = {
25715 (char *) "self",(char *) "datetime", NULL
25716 };
25717
25718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25720 if (!SWIG_IsOK(res1)) {
25721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25722 }
25723 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25725 if (!SWIG_IsOK(res2)) {
25726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25727 }
25728 if (!argp2) {
25729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25730 }
25731 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25732 {
25733 PyThreadState* __tstate = wxPyBeginAllowThreads();
25734 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25735 wxPyEndAllowThreads(__tstate);
25736 if (PyErr_Occurred()) SWIG_fail;
25737 }
25738 {
25739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25740 }
25741 return resultobj;
25742 fail:
25743 return NULL;
25744 }
25745
25746
25747 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25748 PyObject *resultobj = 0;
25749 wxDateTime *arg1 = (wxDateTime *) 0 ;
25750 wxDateTime *arg2 = 0 ;
25751 bool result;
25752 void *argp1 = 0 ;
25753 int res1 = 0 ;
25754 void *argp2 = 0 ;
25755 int res2 = 0 ;
25756 PyObject * obj0 = 0 ;
25757 PyObject * obj1 = 0 ;
25758 char * kwnames[] = {
25759 (char *) "self",(char *) "datetime", NULL
25760 };
25761
25762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25764 if (!SWIG_IsOK(res1)) {
25765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25766 }
25767 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25768 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25769 if (!SWIG_IsOK(res2)) {
25770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25771 }
25772 if (!argp2) {
25773 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25774 }
25775 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25779 wxPyEndAllowThreads(__tstate);
25780 if (PyErr_Occurred()) SWIG_fail;
25781 }
25782 {
25783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25784 }
25785 return resultobj;
25786 fail:
25787 return NULL;
25788 }
25789
25790
25791 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25792 PyObject *resultobj = 0;
25793 wxDateTime *arg1 = (wxDateTime *) 0 ;
25794 wxDateTime *arg2 = 0 ;
25795 bool result;
25796 void *argp1 = 0 ;
25797 int res1 = 0 ;
25798 void *argp2 = 0 ;
25799 int res2 = 0 ;
25800 PyObject * obj0 = 0 ;
25801 PyObject * obj1 = 0 ;
25802 char * kwnames[] = {
25803 (char *) "self",(char *) "datetime", NULL
25804 };
25805
25806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25810 }
25811 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25813 if (!SWIG_IsOK(res2)) {
25814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25815 }
25816 if (!argp2) {
25817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25818 }
25819 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25820 {
25821 PyThreadState* __tstate = wxPyBeginAllowThreads();
25822 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25823 wxPyEndAllowThreads(__tstate);
25824 if (PyErr_Occurred()) SWIG_fail;
25825 }
25826 {
25827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25828 }
25829 return resultobj;
25830 fail:
25831 return NULL;
25832 }
25833
25834
25835 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25836 PyObject *resultobj = 0;
25837 wxDateTime *arg1 = (wxDateTime *) 0 ;
25838 wxDateTime *arg2 = 0 ;
25839 wxDateTime *arg3 = 0 ;
25840 bool result;
25841 void *argp1 = 0 ;
25842 int res1 = 0 ;
25843 void *argp2 = 0 ;
25844 int res2 = 0 ;
25845 void *argp3 = 0 ;
25846 int res3 = 0 ;
25847 PyObject * obj0 = 0 ;
25848 PyObject * obj1 = 0 ;
25849 PyObject * obj2 = 0 ;
25850 char * kwnames[] = {
25851 (char *) "self",(char *) "t1",(char *) "t2", NULL
25852 };
25853
25854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25856 if (!SWIG_IsOK(res1)) {
25857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25858 }
25859 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25861 if (!SWIG_IsOK(res2)) {
25862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25863 }
25864 if (!argp2) {
25865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25866 }
25867 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25868 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25869 if (!SWIG_IsOK(res3)) {
25870 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25871 }
25872 if (!argp3) {
25873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25874 }
25875 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25879 wxPyEndAllowThreads(__tstate);
25880 if (PyErr_Occurred()) SWIG_fail;
25881 }
25882 {
25883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25884 }
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25892 PyObject *resultobj = 0;
25893 wxDateTime *arg1 = (wxDateTime *) 0 ;
25894 wxDateTime *arg2 = 0 ;
25895 wxDateTime *arg3 = 0 ;
25896 bool result;
25897 void *argp1 = 0 ;
25898 int res1 = 0 ;
25899 void *argp2 = 0 ;
25900 int res2 = 0 ;
25901 void *argp3 = 0 ;
25902 int res3 = 0 ;
25903 PyObject * obj0 = 0 ;
25904 PyObject * obj1 = 0 ;
25905 PyObject * obj2 = 0 ;
25906 char * kwnames[] = {
25907 (char *) "self",(char *) "t1",(char *) "t2", NULL
25908 };
25909
25910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25912 if (!SWIG_IsOK(res1)) {
25913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25914 }
25915 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25916 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25917 if (!SWIG_IsOK(res2)) {
25918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25919 }
25920 if (!argp2) {
25921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25922 }
25923 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25924 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25925 if (!SWIG_IsOK(res3)) {
25926 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25927 }
25928 if (!argp3) {
25929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25930 }
25931 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25932 {
25933 PyThreadState* __tstate = wxPyBeginAllowThreads();
25934 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25935 wxPyEndAllowThreads(__tstate);
25936 if (PyErr_Occurred()) SWIG_fail;
25937 }
25938 {
25939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25940 }
25941 return resultobj;
25942 fail:
25943 return NULL;
25944 }
25945
25946
25947 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25948 PyObject *resultobj = 0;
25949 wxDateTime *arg1 = (wxDateTime *) 0 ;
25950 wxDateTime *arg2 = 0 ;
25951 bool result;
25952 void *argp1 = 0 ;
25953 int res1 = 0 ;
25954 void *argp2 = 0 ;
25955 int res2 = 0 ;
25956 PyObject * obj0 = 0 ;
25957 PyObject * obj1 = 0 ;
25958 char * kwnames[] = {
25959 (char *) "self",(char *) "dt", NULL
25960 };
25961
25962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25964 if (!SWIG_IsOK(res1)) {
25965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25966 }
25967 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25969 if (!SWIG_IsOK(res2)) {
25970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25971 }
25972 if (!argp2) {
25973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25974 }
25975 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25976 {
25977 PyThreadState* __tstate = wxPyBeginAllowThreads();
25978 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 {
25983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25984 }
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25992 PyObject *resultobj = 0;
25993 wxDateTime *arg1 = (wxDateTime *) 0 ;
25994 wxDateTime *arg2 = 0 ;
25995 bool result;
25996 void *argp1 = 0 ;
25997 int res1 = 0 ;
25998 void *argp2 = 0 ;
25999 int res2 = 0 ;
26000 PyObject * obj0 = 0 ;
26001 PyObject * obj1 = 0 ;
26002 char * kwnames[] = {
26003 (char *) "self",(char *) "dt", NULL
26004 };
26005
26006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26008 if (!SWIG_IsOK(res1)) {
26009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26010 }
26011 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26012 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26013 if (!SWIG_IsOK(res2)) {
26014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26015 }
26016 if (!argp2) {
26017 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26018 }
26019 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 {
26027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26028 }
26029 return resultobj;
26030 fail:
26031 return NULL;
26032 }
26033
26034
26035 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26036 PyObject *resultobj = 0;
26037 wxDateTime *arg1 = (wxDateTime *) 0 ;
26038 wxDateTime *arg2 = 0 ;
26039 wxTimeSpan *arg3 = 0 ;
26040 bool result;
26041 void *argp1 = 0 ;
26042 int res1 = 0 ;
26043 void *argp2 = 0 ;
26044 int res2 = 0 ;
26045 void *argp3 = 0 ;
26046 int res3 = 0 ;
26047 PyObject * obj0 = 0 ;
26048 PyObject * obj1 = 0 ;
26049 PyObject * obj2 = 0 ;
26050 char * kwnames[] = {
26051 (char *) "self",(char *) "dt",(char *) "ts", NULL
26052 };
26053
26054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26056 if (!SWIG_IsOK(res1)) {
26057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26058 }
26059 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26061 if (!SWIG_IsOK(res2)) {
26062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26063 }
26064 if (!argp2) {
26065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26066 }
26067 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26068 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26069 if (!SWIG_IsOK(res3)) {
26070 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26071 }
26072 if (!argp3) {
26073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26074 }
26075 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 {
26083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26084 }
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26092 PyObject *resultobj = 0;
26093 wxDateTime *arg1 = (wxDateTime *) 0 ;
26094 wxTimeSpan *arg2 = 0 ;
26095 wxDateTime *result = 0 ;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 void *argp2 = 0 ;
26099 int res2 = 0 ;
26100 PyObject * obj0 = 0 ;
26101 PyObject * obj1 = 0 ;
26102 char * kwnames[] = {
26103 (char *) "self",(char *) "diff", NULL
26104 };
26105
26106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
26107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26108 if (!SWIG_IsOK(res1)) {
26109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26110 }
26111 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26112 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26113 if (!SWIG_IsOK(res2)) {
26114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26115 }
26116 if (!argp2) {
26117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26118 }
26119 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26120 {
26121 PyThreadState* __tstate = wxPyBeginAllowThreads();
26122 {
26123 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
26124 result = (wxDateTime *) &_result_ref;
26125 }
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj = 0;
26138 wxDateTime *arg1 = (wxDateTime *) 0 ;
26139 wxDateSpan *arg2 = 0 ;
26140 wxDateTime *result = 0 ;
26141 void *argp1 = 0 ;
26142 int res1 = 0 ;
26143 void *argp2 = 0 ;
26144 int res2 = 0 ;
26145 PyObject * obj0 = 0 ;
26146 PyObject * obj1 = 0 ;
26147 char * kwnames[] = {
26148 (char *) "self",(char *) "diff", NULL
26149 };
26150
26151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
26152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26153 if (!SWIG_IsOK(res1)) {
26154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26155 }
26156 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26158 if (!SWIG_IsOK(res2)) {
26159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26160 }
26161 if (!argp2) {
26162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26163 }
26164 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26165 {
26166 PyThreadState* __tstate = wxPyBeginAllowThreads();
26167 {
26168 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26169 result = (wxDateTime *) &_result_ref;
26170 }
26171 wxPyEndAllowThreads(__tstate);
26172 if (PyErr_Occurred()) SWIG_fail;
26173 }
26174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26175 return resultobj;
26176 fail:
26177 return NULL;
26178 }
26179
26180
26181 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26182 PyObject *resultobj = 0;
26183 wxDateTime *arg1 = (wxDateTime *) 0 ;
26184 wxTimeSpan *arg2 = 0 ;
26185 wxDateTime *result = 0 ;
26186 void *argp1 = 0 ;
26187 int res1 = 0 ;
26188 void *argp2 = 0 ;
26189 int res2 = 0 ;
26190 PyObject * obj0 = 0 ;
26191 PyObject * obj1 = 0 ;
26192 char * kwnames[] = {
26193 (char *) "self",(char *) "diff", NULL
26194 };
26195
26196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26198 if (!SWIG_IsOK(res1)) {
26199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26200 }
26201 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26203 if (!SWIG_IsOK(res2)) {
26204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26205 }
26206 if (!argp2) {
26207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26208 }
26209 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26210 {
26211 PyThreadState* __tstate = wxPyBeginAllowThreads();
26212 {
26213 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26214 result = (wxDateTime *) &_result_ref;
26215 }
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26227 PyObject *resultobj = 0;
26228 wxDateTime *arg1 = (wxDateTime *) 0 ;
26229 wxDateSpan *arg2 = 0 ;
26230 wxDateTime *result = 0 ;
26231 void *argp1 = 0 ;
26232 int res1 = 0 ;
26233 void *argp2 = 0 ;
26234 int res2 = 0 ;
26235 PyObject * obj0 = 0 ;
26236 PyObject * obj1 = 0 ;
26237 char * kwnames[] = {
26238 (char *) "self",(char *) "diff", NULL
26239 };
26240
26241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26243 if (!SWIG_IsOK(res1)) {
26244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26245 }
26246 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26248 if (!SWIG_IsOK(res2)) {
26249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26250 }
26251 if (!argp2) {
26252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26253 }
26254 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26255 {
26256 PyThreadState* __tstate = wxPyBeginAllowThreads();
26257 {
26258 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26259 result = (wxDateTime *) &_result_ref;
26260 }
26261 wxPyEndAllowThreads(__tstate);
26262 if (PyErr_Occurred()) SWIG_fail;
26263 }
26264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26265 return resultobj;
26266 fail:
26267 return NULL;
26268 }
26269
26270
26271 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26272 PyObject *resultobj = 0;
26273 wxDateTime *arg1 = (wxDateTime *) 0 ;
26274 wxDateTime *arg2 = 0 ;
26275 wxTimeSpan result;
26276 void *argp1 = 0 ;
26277 int res1 = 0 ;
26278 void *argp2 = 0 ;
26279 int res2 = 0 ;
26280 PyObject * obj0 = 0 ;
26281 PyObject * obj1 = 0 ;
26282 char * kwnames[] = {
26283 (char *) "self",(char *) "dt", NULL
26284 };
26285
26286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26288 if (!SWIG_IsOK(res1)) {
26289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26290 }
26291 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26292 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26293 if (!SWIG_IsOK(res2)) {
26294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26295 }
26296 if (!argp2) {
26297 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26298 }
26299 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26300 {
26301 PyThreadState* __tstate = wxPyBeginAllowThreads();
26302 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26314 PyObject *resultobj = 0;
26315 wxDateTime *arg1 = (wxDateTime *) 0 ;
26316 wxTimeSpan *arg2 = 0 ;
26317 wxDateTime *result = 0 ;
26318 void *argp1 = 0 ;
26319 int res1 = 0 ;
26320 void *argp2 = 0 ;
26321 int res2 = 0 ;
26322
26323 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26325 if (!SWIG_IsOK(res1)) {
26326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26327 }
26328 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26329 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26330 if (!SWIG_IsOK(res2)) {
26331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26332 }
26333 if (!argp2) {
26334 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26335 }
26336 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 {
26340 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26341 result = (wxDateTime *) &_result_ref;
26342 }
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26354 PyObject *resultobj = 0;
26355 wxDateTime *arg1 = (wxDateTime *) 0 ;
26356 wxDateSpan *arg2 = 0 ;
26357 wxDateTime *result = 0 ;
26358 void *argp1 = 0 ;
26359 int res1 = 0 ;
26360 void *argp2 = 0 ;
26361 int res2 = 0 ;
26362
26363 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26365 if (!SWIG_IsOK(res1)) {
26366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26367 }
26368 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26369 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26370 if (!SWIG_IsOK(res2)) {
26371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26372 }
26373 if (!argp2) {
26374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26375 }
26376 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 {
26380 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26381 result = (wxDateTime *) &_result_ref;
26382 }
26383 wxPyEndAllowThreads(__tstate);
26384 if (PyErr_Occurred()) SWIG_fail;
26385 }
26386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26387 return resultobj;
26388 fail:
26389 return NULL;
26390 }
26391
26392
26393 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26394 int argc;
26395 PyObject *argv[3];
26396
26397 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26398 --argc;
26399 if (argc == 2) {
26400 int _v = 0;
26401 {
26402 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26403 _v = SWIG_CheckState(res);
26404 }
26405 if (!_v) goto check_1;
26406 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26407 }
26408 check_1:
26409
26410 if (argc == 2) {
26411 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26412 }
26413
26414 fail:
26415 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26421 PyObject *resultobj = 0;
26422 wxDateTime *arg1 = (wxDateTime *) 0 ;
26423 wxTimeSpan *arg2 = 0 ;
26424 wxDateTime *result = 0 ;
26425 void *argp1 = 0 ;
26426 int res1 = 0 ;
26427 void *argp2 = 0 ;
26428 int res2 = 0 ;
26429
26430 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26432 if (!SWIG_IsOK(res1)) {
26433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26434 }
26435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26436 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26437 if (!SWIG_IsOK(res2)) {
26438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26439 }
26440 if (!argp2) {
26441 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26442 }
26443 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26444 {
26445 PyThreadState* __tstate = wxPyBeginAllowThreads();
26446 {
26447 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26448 result = (wxDateTime *) &_result_ref;
26449 }
26450 wxPyEndAllowThreads(__tstate);
26451 if (PyErr_Occurred()) SWIG_fail;
26452 }
26453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26454 return resultobj;
26455 fail:
26456 return NULL;
26457 }
26458
26459
26460 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26461 PyObject *resultobj = 0;
26462 wxDateTime *arg1 = (wxDateTime *) 0 ;
26463 wxDateSpan *arg2 = 0 ;
26464 wxDateTime *result = 0 ;
26465 void *argp1 = 0 ;
26466 int res1 = 0 ;
26467 void *argp2 = 0 ;
26468 int res2 = 0 ;
26469
26470 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26472 if (!SWIG_IsOK(res1)) {
26473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26474 }
26475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26476 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26477 if (!SWIG_IsOK(res2)) {
26478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26479 }
26480 if (!argp2) {
26481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26482 }
26483 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 {
26487 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26488 result = (wxDateTime *) &_result_ref;
26489 }
26490 wxPyEndAllowThreads(__tstate);
26491 if (PyErr_Occurred()) SWIG_fail;
26492 }
26493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26494 return resultobj;
26495 fail:
26496 return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26501 int argc;
26502 PyObject *argv[3];
26503
26504 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26505 --argc;
26506 if (argc == 2) {
26507 int _v = 0;
26508 {
26509 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26510 _v = SWIG_CheckState(res);
26511 }
26512 if (!_v) goto check_1;
26513 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26514 }
26515 check_1:
26516
26517 if (argc == 2) {
26518 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26519 }
26520
26521 fail:
26522 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26523 return NULL;
26524 }
26525
26526
26527 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26528 PyObject *resultobj = 0;
26529 wxDateTime *arg1 = (wxDateTime *) 0 ;
26530 wxTimeSpan *arg2 = 0 ;
26531 wxDateTime result;
26532 void *argp1 = 0 ;
26533 int res1 = 0 ;
26534 void *argp2 = 0 ;
26535 int res2 = 0 ;
26536
26537 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26539 if (!SWIG_IsOK(res1)) {
26540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26541 }
26542 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26543 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26544 if (!SWIG_IsOK(res2)) {
26545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26546 }
26547 if (!argp2) {
26548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26549 }
26550 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26565 PyObject *resultobj = 0;
26566 wxDateTime *arg1 = (wxDateTime *) 0 ;
26567 wxDateSpan *arg2 = 0 ;
26568 wxDateTime result;
26569 void *argp1 = 0 ;
26570 int res1 = 0 ;
26571 void *argp2 = 0 ;
26572 int res2 = 0 ;
26573
26574 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26576 if (!SWIG_IsOK(res1)) {
26577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26578 }
26579 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26580 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26581 if (!SWIG_IsOK(res2)) {
26582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26583 }
26584 if (!argp2) {
26585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26586 }
26587 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26595 return resultobj;
26596 fail:
26597 return NULL;
26598 }
26599
26600
26601 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26602 int argc;
26603 PyObject *argv[3];
26604
26605 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26606 --argc;
26607 if (argc == 2) {
26608 int _v = 0;
26609 {
26610 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26611 _v = SWIG_CheckState(res);
26612 }
26613 if (!_v) goto check_1;
26614 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26615 }
26616 check_1:
26617
26618 if (argc == 2) {
26619 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26620 }
26621
26622 fail:
26623 Py_INCREF(Py_NotImplemented);
26624 return Py_NotImplemented;
26625 }
26626
26627
26628 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26629 PyObject *resultobj = 0;
26630 wxDateTime *arg1 = (wxDateTime *) 0 ;
26631 wxDateTime *arg2 = 0 ;
26632 wxTimeSpan result;
26633 void *argp1 = 0 ;
26634 int res1 = 0 ;
26635 void *argp2 = 0 ;
26636 int res2 = 0 ;
26637
26638 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26640 if (!SWIG_IsOK(res1)) {
26641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26642 }
26643 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26644 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26645 if (!SWIG_IsOK(res2)) {
26646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26647 }
26648 if (!argp2) {
26649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26650 }
26651 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26652 {
26653 PyThreadState* __tstate = wxPyBeginAllowThreads();
26654 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26655 wxPyEndAllowThreads(__tstate);
26656 if (PyErr_Occurred()) SWIG_fail;
26657 }
26658 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26659 return resultobj;
26660 fail:
26661 return NULL;
26662 }
26663
26664
26665 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26666 PyObject *resultobj = 0;
26667 wxDateTime *arg1 = (wxDateTime *) 0 ;
26668 wxTimeSpan *arg2 = 0 ;
26669 wxDateTime result;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 void *argp2 = 0 ;
26673 int res2 = 0 ;
26674
26675 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26677 if (!SWIG_IsOK(res1)) {
26678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26679 }
26680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26681 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26682 if (!SWIG_IsOK(res2)) {
26683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26684 }
26685 if (!argp2) {
26686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26687 }
26688 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26689 {
26690 PyThreadState* __tstate = wxPyBeginAllowThreads();
26691 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26696 return resultobj;
26697 fail:
26698 return NULL;
26699 }
26700
26701
26702 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26703 PyObject *resultobj = 0;
26704 wxDateTime *arg1 = (wxDateTime *) 0 ;
26705 wxDateSpan *arg2 = 0 ;
26706 wxDateTime result;
26707 void *argp1 = 0 ;
26708 int res1 = 0 ;
26709 void *argp2 = 0 ;
26710 int res2 = 0 ;
26711
26712 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26714 if (!SWIG_IsOK(res1)) {
26715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26716 }
26717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26718 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26719 if (!SWIG_IsOK(res2)) {
26720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26721 }
26722 if (!argp2) {
26723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26724 }
26725 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26726 {
26727 PyThreadState* __tstate = wxPyBeginAllowThreads();
26728 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26729 wxPyEndAllowThreads(__tstate);
26730 if (PyErr_Occurred()) SWIG_fail;
26731 }
26732 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26733 return resultobj;
26734 fail:
26735 return NULL;
26736 }
26737
26738
26739 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26740 int argc;
26741 PyObject *argv[3];
26742
26743 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26744 --argc;
26745 if (argc == 2) {
26746 int _v = 0;
26747 {
26748 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26749 _v = SWIG_CheckState(res);
26750 }
26751 if (!_v) goto check_1;
26752 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26753 }
26754 check_1:
26755
26756 if (argc == 2) {
26757 int _v = 0;
26758 {
26759 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26760 _v = SWIG_CheckState(res);
26761 }
26762 if (!_v) goto check_2;
26763 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26764 }
26765 check_2:
26766
26767 if (argc == 2) {
26768 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26769 }
26770
26771 fail:
26772 Py_INCREF(Py_NotImplemented);
26773 return Py_NotImplemented;
26774 }
26775
26776
26777 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26778 PyObject *resultobj = 0;
26779 wxDateTime *arg1 = (wxDateTime *) 0 ;
26780 wxDateTime *arg2 = (wxDateTime *) 0 ;
26781 bool result;
26782 void *argp1 = 0 ;
26783 int res1 = 0 ;
26784 void *argp2 = 0 ;
26785 int res2 = 0 ;
26786 PyObject * obj0 = 0 ;
26787 PyObject * obj1 = 0 ;
26788 char * kwnames[] = {
26789 (char *) "self",(char *) "other", NULL
26790 };
26791
26792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26794 if (!SWIG_IsOK(res1)) {
26795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26796 }
26797 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26799 if (!SWIG_IsOK(res2)) {
26800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26801 }
26802 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26803 {
26804 PyThreadState* __tstate = wxPyBeginAllowThreads();
26805 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26806 wxPyEndAllowThreads(__tstate);
26807 if (PyErr_Occurred()) SWIG_fail;
26808 }
26809 {
26810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26811 }
26812 return resultobj;
26813 fail:
26814 return NULL;
26815 }
26816
26817
26818 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26819 PyObject *resultobj = 0;
26820 wxDateTime *arg1 = (wxDateTime *) 0 ;
26821 wxDateTime *arg2 = (wxDateTime *) 0 ;
26822 bool result;
26823 void *argp1 = 0 ;
26824 int res1 = 0 ;
26825 void *argp2 = 0 ;
26826 int res2 = 0 ;
26827 PyObject * obj0 = 0 ;
26828 PyObject * obj1 = 0 ;
26829 char * kwnames[] = {
26830 (char *) "self",(char *) "other", NULL
26831 };
26832
26833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26835 if (!SWIG_IsOK(res1)) {
26836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26837 }
26838 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26840 if (!SWIG_IsOK(res2)) {
26841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26842 }
26843 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 {
26851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26852 }
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj = 0;
26861 wxDateTime *arg1 = (wxDateTime *) 0 ;
26862 wxDateTime *arg2 = (wxDateTime *) 0 ;
26863 bool result;
26864 void *argp1 = 0 ;
26865 int res1 = 0 ;
26866 void *argp2 = 0 ;
26867 int res2 = 0 ;
26868 PyObject * obj0 = 0 ;
26869 PyObject * obj1 = 0 ;
26870 char * kwnames[] = {
26871 (char *) "self",(char *) "other", NULL
26872 };
26873
26874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26876 if (!SWIG_IsOK(res1)) {
26877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26878 }
26879 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26881 if (!SWIG_IsOK(res2)) {
26882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26883 }
26884 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26888 wxPyEndAllowThreads(__tstate);
26889 if (PyErr_Occurred()) SWIG_fail;
26890 }
26891 {
26892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26893 }
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj = 0;
26902 wxDateTime *arg1 = (wxDateTime *) 0 ;
26903 wxDateTime *arg2 = (wxDateTime *) 0 ;
26904 bool result;
26905 void *argp1 = 0 ;
26906 int res1 = 0 ;
26907 void *argp2 = 0 ;
26908 int res2 = 0 ;
26909 PyObject * obj0 = 0 ;
26910 PyObject * obj1 = 0 ;
26911 char * kwnames[] = {
26912 (char *) "self",(char *) "other", NULL
26913 };
26914
26915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26917 if (!SWIG_IsOK(res1)) {
26918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26919 }
26920 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26922 if (!SWIG_IsOK(res2)) {
26923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26924 }
26925 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26926 {
26927 PyThreadState* __tstate = wxPyBeginAllowThreads();
26928 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26929 wxPyEndAllowThreads(__tstate);
26930 if (PyErr_Occurred()) SWIG_fail;
26931 }
26932 {
26933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26934 }
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26942 PyObject *resultobj = 0;
26943 wxDateTime *arg1 = (wxDateTime *) 0 ;
26944 wxDateTime *arg2 = (wxDateTime *) 0 ;
26945 bool result;
26946 void *argp1 = 0 ;
26947 int res1 = 0 ;
26948 void *argp2 = 0 ;
26949 int res2 = 0 ;
26950 PyObject * obj0 = 0 ;
26951 PyObject * obj1 = 0 ;
26952 char * kwnames[] = {
26953 (char *) "self",(char *) "other", NULL
26954 };
26955
26956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26958 if (!SWIG_IsOK(res1)) {
26959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26960 }
26961 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26962 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26963 if (!SWIG_IsOK(res2)) {
26964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26965 }
26966 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26967 {
26968 PyThreadState* __tstate = wxPyBeginAllowThreads();
26969 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26970 wxPyEndAllowThreads(__tstate);
26971 if (PyErr_Occurred()) SWIG_fail;
26972 }
26973 {
26974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26975 }
26976 return resultobj;
26977 fail:
26978 return NULL;
26979 }
26980
26981
26982 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26983 PyObject *resultobj = 0;
26984 wxDateTime *arg1 = (wxDateTime *) 0 ;
26985 wxDateTime *arg2 = (wxDateTime *) 0 ;
26986 bool result;
26987 void *argp1 = 0 ;
26988 int res1 = 0 ;
26989 void *argp2 = 0 ;
26990 int res2 = 0 ;
26991 PyObject * obj0 = 0 ;
26992 PyObject * obj1 = 0 ;
26993 char * kwnames[] = {
26994 (char *) "self",(char *) "other", NULL
26995 };
26996
26997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26999 if (!SWIG_IsOK(res1)) {
27000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27001 }
27002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27004 if (!SWIG_IsOK(res2)) {
27005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27006 }
27007 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 {
27015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27016 }
27017 return resultobj;
27018 fail:
27019 return NULL;
27020 }
27021
27022
27023 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27024 PyObject *resultobj = 0;
27025 wxDateTime *arg1 = (wxDateTime *) 0 ;
27026 wxString *arg2 = 0 ;
27027 int result;
27028 void *argp1 = 0 ;
27029 int res1 = 0 ;
27030 bool temp2 = false ;
27031 PyObject * obj0 = 0 ;
27032 PyObject * obj1 = 0 ;
27033 char * kwnames[] = {
27034 (char *) "self",(char *) "date", NULL
27035 };
27036
27037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27039 if (!SWIG_IsOK(res1)) {
27040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27041 }
27042 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27043 {
27044 arg2 = wxString_in_helper(obj1);
27045 if (arg2 == NULL) SWIG_fail;
27046 temp2 = true;
27047 }
27048 {
27049 PyThreadState* __tstate = wxPyBeginAllowThreads();
27050 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
27051 wxPyEndAllowThreads(__tstate);
27052 if (PyErr_Occurred()) SWIG_fail;
27053 }
27054 resultobj = SWIG_From_int(static_cast< int >(result));
27055 {
27056 if (temp2)
27057 delete arg2;
27058 }
27059 return resultobj;
27060 fail:
27061 {
27062 if (temp2)
27063 delete arg2;
27064 }
27065 return NULL;
27066 }
27067
27068
27069 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27070 PyObject *resultobj = 0;
27071 wxDateTime *arg1 = (wxDateTime *) 0 ;
27072 wxString *arg2 = 0 ;
27073 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27074 wxString *arg3 = (wxString *) &arg3_defvalue ;
27075 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27076 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27077 int result;
27078 void *argp1 = 0 ;
27079 int res1 = 0 ;
27080 bool temp2 = false ;
27081 bool temp3 = false ;
27082 void *argp4 = 0 ;
27083 int res4 = 0 ;
27084 PyObject * obj0 = 0 ;
27085 PyObject * obj1 = 0 ;
27086 PyObject * obj2 = 0 ;
27087 PyObject * obj3 = 0 ;
27088 char * kwnames[] = {
27089 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27090 };
27091
27092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27094 if (!SWIG_IsOK(res1)) {
27095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27096 }
27097 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27098 {
27099 arg2 = wxString_in_helper(obj1);
27100 if (arg2 == NULL) SWIG_fail;
27101 temp2 = true;
27102 }
27103 if (obj2) {
27104 {
27105 arg3 = wxString_in_helper(obj2);
27106 if (arg3 == NULL) SWIG_fail;
27107 temp3 = true;
27108 }
27109 }
27110 if (obj3) {
27111 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
27112 if (!SWIG_IsOK(res4)) {
27113 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27114 }
27115 if (!argp4) {
27116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27117 }
27118 arg4 = reinterpret_cast< wxDateTime * >(argp4);
27119 }
27120 {
27121 PyThreadState* __tstate = wxPyBeginAllowThreads();
27122 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
27123 wxPyEndAllowThreads(__tstate);
27124 if (PyErr_Occurred()) SWIG_fail;
27125 }
27126 resultobj = SWIG_From_int(static_cast< int >(result));
27127 {
27128 if (temp2)
27129 delete arg2;
27130 }
27131 {
27132 if (temp3)
27133 delete arg3;
27134 }
27135 return resultobj;
27136 fail:
27137 {
27138 if (temp2)
27139 delete arg2;
27140 }
27141 {
27142 if (temp3)
27143 delete arg3;
27144 }
27145 return NULL;
27146 }
27147
27148
27149 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27150 PyObject *resultobj = 0;
27151 wxDateTime *arg1 = (wxDateTime *) 0 ;
27152 wxString *arg2 = 0 ;
27153 int result;
27154 void *argp1 = 0 ;
27155 int res1 = 0 ;
27156 bool temp2 = false ;
27157 PyObject * obj0 = 0 ;
27158 PyObject * obj1 = 0 ;
27159 char * kwnames[] = {
27160 (char *) "self",(char *) "datetime", NULL
27161 };
27162
27163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
27164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27165 if (!SWIG_IsOK(res1)) {
27166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27167 }
27168 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27169 {
27170 arg2 = wxString_in_helper(obj1);
27171 if (arg2 == NULL) SWIG_fail;
27172 temp2 = true;
27173 }
27174 {
27175 PyThreadState* __tstate = wxPyBeginAllowThreads();
27176 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 resultobj = SWIG_From_int(static_cast< int >(result));
27181 {
27182 if (temp2)
27183 delete arg2;
27184 }
27185 return resultobj;
27186 fail:
27187 {
27188 if (temp2)
27189 delete arg2;
27190 }
27191 return NULL;
27192 }
27193
27194
27195 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27196 PyObject *resultobj = 0;
27197 wxDateTime *arg1 = (wxDateTime *) 0 ;
27198 wxString *arg2 = 0 ;
27199 int result;
27200 void *argp1 = 0 ;
27201 int res1 = 0 ;
27202 bool temp2 = false ;
27203 PyObject * obj0 = 0 ;
27204 PyObject * obj1 = 0 ;
27205 char * kwnames[] = {
27206 (char *) "self",(char *) "date", NULL
27207 };
27208
27209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27211 if (!SWIG_IsOK(res1)) {
27212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27213 }
27214 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27215 {
27216 arg2 = wxString_in_helper(obj1);
27217 if (arg2 == NULL) SWIG_fail;
27218 temp2 = true;
27219 }
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 resultobj = SWIG_From_int(static_cast< int >(result));
27227 {
27228 if (temp2)
27229 delete arg2;
27230 }
27231 return resultobj;
27232 fail:
27233 {
27234 if (temp2)
27235 delete arg2;
27236 }
27237 return NULL;
27238 }
27239
27240
27241 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27242 PyObject *resultobj = 0;
27243 wxDateTime *arg1 = (wxDateTime *) 0 ;
27244 wxString *arg2 = 0 ;
27245 int result;
27246 void *argp1 = 0 ;
27247 int res1 = 0 ;
27248 bool temp2 = false ;
27249 PyObject * obj0 = 0 ;
27250 PyObject * obj1 = 0 ;
27251 char * kwnames[] = {
27252 (char *) "self",(char *) "time", NULL
27253 };
27254
27255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27257 if (!SWIG_IsOK(res1)) {
27258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27259 }
27260 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27261 {
27262 arg2 = wxString_in_helper(obj1);
27263 if (arg2 == NULL) SWIG_fail;
27264 temp2 = true;
27265 }
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 resultobj = SWIG_From_int(static_cast< int >(result));
27273 {
27274 if (temp2)
27275 delete arg2;
27276 }
27277 return resultobj;
27278 fail:
27279 {
27280 if (temp2)
27281 delete arg2;
27282 }
27283 return NULL;
27284 }
27285
27286
27287 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27288 PyObject *resultobj = 0;
27289 wxDateTime *arg1 = (wxDateTime *) 0 ;
27290 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27291 wxString *arg2 = (wxString *) &arg2_defvalue ;
27292 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27293 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27294 wxString result;
27295 void *argp1 = 0 ;
27296 int res1 = 0 ;
27297 bool temp2 = false ;
27298 bool temp3 = false ;
27299 PyObject * obj0 = 0 ;
27300 PyObject * obj1 = 0 ;
27301 PyObject * obj2 = 0 ;
27302 char * kwnames[] = {
27303 (char *) "self",(char *) "format",(char *) "tz", NULL
27304 };
27305
27306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27308 if (!SWIG_IsOK(res1)) {
27309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27310 }
27311 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27312 if (obj1) {
27313 {
27314 arg2 = wxString_in_helper(obj1);
27315 if (arg2 == NULL) SWIG_fail;
27316 temp2 = true;
27317 }
27318 }
27319 if (obj2) {
27320 {
27321 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27322 temp3 = true;
27323 }
27324 }
27325 {
27326 PyThreadState* __tstate = wxPyBeginAllowThreads();
27327 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27328 wxPyEndAllowThreads(__tstate);
27329 if (PyErr_Occurred()) SWIG_fail;
27330 }
27331 {
27332 #if wxUSE_UNICODE
27333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27334 #else
27335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27336 #endif
27337 }
27338 {
27339 if (temp2)
27340 delete arg2;
27341 }
27342 {
27343 if (temp3) delete arg3;
27344 }
27345 return resultobj;
27346 fail:
27347 {
27348 if (temp2)
27349 delete arg2;
27350 }
27351 {
27352 if (temp3) delete arg3;
27353 }
27354 return NULL;
27355 }
27356
27357
27358 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27359 PyObject *resultobj = 0;
27360 wxDateTime *arg1 = (wxDateTime *) 0 ;
27361 wxString result;
27362 void *argp1 = 0 ;
27363 int res1 = 0 ;
27364 PyObject *swig_obj[1] ;
27365
27366 if (!args) SWIG_fail;
27367 swig_obj[0] = args;
27368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27369 if (!SWIG_IsOK(res1)) {
27370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27371 }
27372 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 result = ((wxDateTime const *)arg1)->FormatDate();
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 {
27380 #if wxUSE_UNICODE
27381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27382 #else
27383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27384 #endif
27385 }
27386 return resultobj;
27387 fail:
27388 return NULL;
27389 }
27390
27391
27392 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27393 PyObject *resultobj = 0;
27394 wxDateTime *arg1 = (wxDateTime *) 0 ;
27395 wxString result;
27396 void *argp1 = 0 ;
27397 int res1 = 0 ;
27398 PyObject *swig_obj[1] ;
27399
27400 if (!args) SWIG_fail;
27401 swig_obj[0] = args;
27402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27403 if (!SWIG_IsOK(res1)) {
27404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27405 }
27406 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27407 {
27408 PyThreadState* __tstate = wxPyBeginAllowThreads();
27409 result = ((wxDateTime const *)arg1)->FormatTime();
27410 wxPyEndAllowThreads(__tstate);
27411 if (PyErr_Occurred()) SWIG_fail;
27412 }
27413 {
27414 #if wxUSE_UNICODE
27415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27416 #else
27417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27418 #endif
27419 }
27420 return resultobj;
27421 fail:
27422 return NULL;
27423 }
27424
27425
27426 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27427 PyObject *resultobj = 0;
27428 wxDateTime *arg1 = (wxDateTime *) 0 ;
27429 wxString result;
27430 void *argp1 = 0 ;
27431 int res1 = 0 ;
27432 PyObject *swig_obj[1] ;
27433
27434 if (!args) SWIG_fail;
27435 swig_obj[0] = args;
27436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27437 if (!SWIG_IsOK(res1)) {
27438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27439 }
27440 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 result = ((wxDateTime const *)arg1)->FormatISODate();
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 {
27448 #if wxUSE_UNICODE
27449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27450 #else
27451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27452 #endif
27453 }
27454 return resultobj;
27455 fail:
27456 return NULL;
27457 }
27458
27459
27460 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27461 PyObject *resultobj = 0;
27462 wxDateTime *arg1 = (wxDateTime *) 0 ;
27463 wxString result;
27464 void *argp1 = 0 ;
27465 int res1 = 0 ;
27466 PyObject *swig_obj[1] ;
27467
27468 if (!args) SWIG_fail;
27469 swig_obj[0] = args;
27470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27471 if (!SWIG_IsOK(res1)) {
27472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27473 }
27474 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 result = ((wxDateTime const *)arg1)->FormatISOTime();
27478 wxPyEndAllowThreads(__tstate);
27479 if (PyErr_Occurred()) SWIG_fail;
27480 }
27481 {
27482 #if wxUSE_UNICODE
27483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27484 #else
27485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27486 #endif
27487 }
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27495 PyObject *obj;
27496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27497 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27498 return SWIG_Py_Void();
27499 }
27500
27501 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27502 return SWIG_Python_InitShadowInstance(args);
27503 }
27504
27505 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27506 PyObject *resultobj = 0;
27507 long arg1 ;
27508 wxTimeSpan result;
27509 long val1 ;
27510 int ecode1 = 0 ;
27511 PyObject * obj0 = 0 ;
27512 char * kwnames[] = {
27513 (char *) "ms", NULL
27514 };
27515
27516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27517 ecode1 = SWIG_AsVal_long(obj0, &val1);
27518 if (!SWIG_IsOK(ecode1)) {
27519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27520 }
27521 arg1 = static_cast< long >(val1);
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 result = wxTimeSpan::Milliseconds(arg1);
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27529 return resultobj;
27530 fail:
27531 return NULL;
27532 }
27533
27534
27535 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27536 PyObject *resultobj = 0;
27537 wxTimeSpan result;
27538
27539 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27540 {
27541 PyThreadState* __tstate = wxPyBeginAllowThreads();
27542 result = wxTimeSpan::Millisecond();
27543 wxPyEndAllowThreads(__tstate);
27544 if (PyErr_Occurred()) SWIG_fail;
27545 }
27546 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27554 PyObject *resultobj = 0;
27555 long arg1 ;
27556 wxTimeSpan result;
27557 long val1 ;
27558 int ecode1 = 0 ;
27559 PyObject * obj0 = 0 ;
27560 char * kwnames[] = {
27561 (char *) "sec", NULL
27562 };
27563
27564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27565 ecode1 = SWIG_AsVal_long(obj0, &val1);
27566 if (!SWIG_IsOK(ecode1)) {
27567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27568 }
27569 arg1 = static_cast< long >(val1);
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 result = wxTimeSpan::Seconds(arg1);
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27584 PyObject *resultobj = 0;
27585 wxTimeSpan result;
27586
27587 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27588 {
27589 PyThreadState* __tstate = wxPyBeginAllowThreads();
27590 result = wxTimeSpan::Second();
27591 wxPyEndAllowThreads(__tstate);
27592 if (PyErr_Occurred()) SWIG_fail;
27593 }
27594 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27595 return resultobj;
27596 fail:
27597 return NULL;
27598 }
27599
27600
27601 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27602 PyObject *resultobj = 0;
27603 long arg1 ;
27604 wxTimeSpan result;
27605 long val1 ;
27606 int ecode1 = 0 ;
27607 PyObject * obj0 = 0 ;
27608 char * kwnames[] = {
27609 (char *) "min", NULL
27610 };
27611
27612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27613 ecode1 = SWIG_AsVal_long(obj0, &val1);
27614 if (!SWIG_IsOK(ecode1)) {
27615 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27616 }
27617 arg1 = static_cast< long >(val1);
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 result = wxTimeSpan::Minutes(arg1);
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27625 return resultobj;
27626 fail:
27627 return NULL;
27628 }
27629
27630
27631 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27632 PyObject *resultobj = 0;
27633 wxTimeSpan result;
27634
27635 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = wxTimeSpan::Minute();
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27650 PyObject *resultobj = 0;
27651 long arg1 ;
27652 wxTimeSpan result;
27653 long val1 ;
27654 int ecode1 = 0 ;
27655 PyObject * obj0 = 0 ;
27656 char * kwnames[] = {
27657 (char *) "hours", NULL
27658 };
27659
27660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27661 ecode1 = SWIG_AsVal_long(obj0, &val1);
27662 if (!SWIG_IsOK(ecode1)) {
27663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27664 }
27665 arg1 = static_cast< long >(val1);
27666 {
27667 PyThreadState* __tstate = wxPyBeginAllowThreads();
27668 result = wxTimeSpan::Hours(arg1);
27669 wxPyEndAllowThreads(__tstate);
27670 if (PyErr_Occurred()) SWIG_fail;
27671 }
27672 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27680 PyObject *resultobj = 0;
27681 wxTimeSpan result;
27682
27683 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 result = wxTimeSpan::Hour();
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj = 0;
27699 long arg1 ;
27700 wxTimeSpan result;
27701 long val1 ;
27702 int ecode1 = 0 ;
27703 PyObject * obj0 = 0 ;
27704 char * kwnames[] = {
27705 (char *) "days", NULL
27706 };
27707
27708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27709 ecode1 = SWIG_AsVal_long(obj0, &val1);
27710 if (!SWIG_IsOK(ecode1)) {
27711 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27712 }
27713 arg1 = static_cast< long >(val1);
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = wxTimeSpan::Days(arg1);
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27721 return resultobj;
27722 fail:
27723 return NULL;
27724 }
27725
27726
27727 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27728 PyObject *resultobj = 0;
27729 wxTimeSpan result;
27730
27731 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27732 {
27733 PyThreadState* __tstate = wxPyBeginAllowThreads();
27734 result = wxTimeSpan::Day();
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27746 PyObject *resultobj = 0;
27747 long arg1 ;
27748 wxTimeSpan result;
27749 long val1 ;
27750 int ecode1 = 0 ;
27751 PyObject * obj0 = 0 ;
27752 char * kwnames[] = {
27753 (char *) "days", NULL
27754 };
27755
27756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27757 ecode1 = SWIG_AsVal_long(obj0, &val1);
27758 if (!SWIG_IsOK(ecode1)) {
27759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27760 }
27761 arg1 = static_cast< long >(val1);
27762 {
27763 PyThreadState* __tstate = wxPyBeginAllowThreads();
27764 result = wxTimeSpan::Weeks(arg1);
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27776 PyObject *resultobj = 0;
27777 wxTimeSpan result;
27778
27779 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27780 {
27781 PyThreadState* __tstate = wxPyBeginAllowThreads();
27782 result = wxTimeSpan::Week();
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj = 0;
27795 long arg1 = (long) 0 ;
27796 long arg2 = (long) 0 ;
27797 long arg3 = (long) 0 ;
27798 long arg4 = (long) 0 ;
27799 wxTimeSpan *result = 0 ;
27800 long val1 ;
27801 int ecode1 = 0 ;
27802 long val2 ;
27803 int ecode2 = 0 ;
27804 long val3 ;
27805 int ecode3 = 0 ;
27806 long val4 ;
27807 int ecode4 = 0 ;
27808 PyObject * obj0 = 0 ;
27809 PyObject * obj1 = 0 ;
27810 PyObject * obj2 = 0 ;
27811 PyObject * obj3 = 0 ;
27812 char * kwnames[] = {
27813 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27814 };
27815
27816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27817 if (obj0) {
27818 ecode1 = SWIG_AsVal_long(obj0, &val1);
27819 if (!SWIG_IsOK(ecode1)) {
27820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27821 }
27822 arg1 = static_cast< long >(val1);
27823 }
27824 if (obj1) {
27825 ecode2 = SWIG_AsVal_long(obj1, &val2);
27826 if (!SWIG_IsOK(ecode2)) {
27827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27828 }
27829 arg2 = static_cast< long >(val2);
27830 }
27831 if (obj2) {
27832 ecode3 = SWIG_AsVal_long(obj2, &val3);
27833 if (!SWIG_IsOK(ecode3)) {
27834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27835 }
27836 arg3 = static_cast< long >(val3);
27837 }
27838 if (obj3) {
27839 ecode4 = SWIG_AsVal_long(obj3, &val4);
27840 if (!SWIG_IsOK(ecode4)) {
27841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27842 }
27843 arg4 = static_cast< long >(val4);
27844 }
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27848 wxPyEndAllowThreads(__tstate);
27849 if (PyErr_Occurred()) SWIG_fail;
27850 }
27851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27859 PyObject *resultobj = 0;
27860 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27861 void *argp1 = 0 ;
27862 int res1 = 0 ;
27863 PyObject *swig_obj[1] ;
27864
27865 if (!args) SWIG_fail;
27866 swig_obj[0] = args;
27867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27868 if (!SWIG_IsOK(res1)) {
27869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27870 }
27871 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 delete arg1;
27875
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 resultobj = SWIG_Py_Void();
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj = 0;
27888 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27889 wxTimeSpan *arg2 = 0 ;
27890 wxTimeSpan *result = 0 ;
27891 void *argp1 = 0 ;
27892 int res1 = 0 ;
27893 void *argp2 = 0 ;
27894 int res2 = 0 ;
27895 PyObject * obj0 = 0 ;
27896 PyObject * obj1 = 0 ;
27897 char * kwnames[] = {
27898 (char *) "self",(char *) "diff", NULL
27899 };
27900
27901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27903 if (!SWIG_IsOK(res1)) {
27904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27905 }
27906 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27907 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27908 if (!SWIG_IsOK(res2)) {
27909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27910 }
27911 if (!argp2) {
27912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27913 }
27914 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 {
27918 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27919 result = (wxTimeSpan *) &_result_ref;
27920 }
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27932 PyObject *resultobj = 0;
27933 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27934 wxTimeSpan *arg2 = 0 ;
27935 wxTimeSpan *result = 0 ;
27936 void *argp1 = 0 ;
27937 int res1 = 0 ;
27938 void *argp2 = 0 ;
27939 int res2 = 0 ;
27940 PyObject * obj0 = 0 ;
27941 PyObject * obj1 = 0 ;
27942 char * kwnames[] = {
27943 (char *) "self",(char *) "diff", NULL
27944 };
27945
27946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27948 if (!SWIG_IsOK(res1)) {
27949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27950 }
27951 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27952 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27953 if (!SWIG_IsOK(res2)) {
27954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27955 }
27956 if (!argp2) {
27957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27958 }
27959 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 {
27963 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27964 result = (wxTimeSpan *) &_result_ref;
27965 }
27966 wxPyEndAllowThreads(__tstate);
27967 if (PyErr_Occurred()) SWIG_fail;
27968 }
27969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27977 PyObject *resultobj = 0;
27978 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27979 int arg2 ;
27980 wxTimeSpan *result = 0 ;
27981 void *argp1 = 0 ;
27982 int res1 = 0 ;
27983 int val2 ;
27984 int ecode2 = 0 ;
27985 PyObject * obj0 = 0 ;
27986 PyObject * obj1 = 0 ;
27987 char * kwnames[] = {
27988 (char *) "self",(char *) "n", NULL
27989 };
27990
27991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27993 if (!SWIG_IsOK(res1)) {
27994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27995 }
27996 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27997 ecode2 = SWIG_AsVal_int(obj1, &val2);
27998 if (!SWIG_IsOK(ecode2)) {
27999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
28000 }
28001 arg2 = static_cast< int >(val2);
28002 {
28003 PyThreadState* __tstate = wxPyBeginAllowThreads();
28004 {
28005 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
28006 result = (wxTimeSpan *) &_result_ref;
28007 }
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28012 return resultobj;
28013 fail:
28014 return NULL;
28015 }
28016
28017
28018 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28019 PyObject *resultobj = 0;
28020 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28021 wxTimeSpan *result = 0 ;
28022 void *argp1 = 0 ;
28023 int res1 = 0 ;
28024 PyObject *swig_obj[1] ;
28025
28026 if (!args) SWIG_fail;
28027 swig_obj[0] = args;
28028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28029 if (!SWIG_IsOK(res1)) {
28030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28031 }
28032 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 {
28036 wxTimeSpan &_result_ref = (arg1)->Neg();
28037 result = (wxTimeSpan *) &_result_ref;
28038 }
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28050 PyObject *resultobj = 0;
28051 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28052 wxTimeSpan result;
28053 void *argp1 = 0 ;
28054 int res1 = 0 ;
28055 PyObject *swig_obj[1] ;
28056
28057 if (!args) SWIG_fail;
28058 swig_obj[0] = args;
28059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28060 if (!SWIG_IsOK(res1)) {
28061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28062 }
28063 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 result = ((wxTimeSpan const *)arg1)->Abs();
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28078 PyObject *resultobj = 0;
28079 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28080 wxTimeSpan *arg2 = 0 ;
28081 wxTimeSpan *result = 0 ;
28082 void *argp1 = 0 ;
28083 int res1 = 0 ;
28084 void *argp2 = 0 ;
28085 int res2 = 0 ;
28086 PyObject * obj0 = 0 ;
28087 PyObject * obj1 = 0 ;
28088 char * kwnames[] = {
28089 (char *) "self",(char *) "diff", NULL
28090 };
28091
28092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28094 if (!SWIG_IsOK(res1)) {
28095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28096 }
28097 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28099 if (!SWIG_IsOK(res2)) {
28100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28101 }
28102 if (!argp2) {
28103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28104 }
28105 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 {
28109 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
28110 result = (wxTimeSpan *) &_result_ref;
28111 }
28112 wxPyEndAllowThreads(__tstate);
28113 if (PyErr_Occurred()) SWIG_fail;
28114 }
28115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28116 return resultobj;
28117 fail:
28118 return NULL;
28119 }
28120
28121
28122 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28123 PyObject *resultobj = 0;
28124 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28125 wxTimeSpan *arg2 = 0 ;
28126 wxTimeSpan *result = 0 ;
28127 void *argp1 = 0 ;
28128 int res1 = 0 ;
28129 void *argp2 = 0 ;
28130 int res2 = 0 ;
28131 PyObject * obj0 = 0 ;
28132 PyObject * obj1 = 0 ;
28133 char * kwnames[] = {
28134 (char *) "self",(char *) "diff", NULL
28135 };
28136
28137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
28138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28139 if (!SWIG_IsOK(res1)) {
28140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28141 }
28142 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28143 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28144 if (!SWIG_IsOK(res2)) {
28145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28146 }
28147 if (!argp2) {
28148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28149 }
28150 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28151 {
28152 PyThreadState* __tstate = wxPyBeginAllowThreads();
28153 {
28154 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
28155 result = (wxTimeSpan *) &_result_ref;
28156 }
28157 wxPyEndAllowThreads(__tstate);
28158 if (PyErr_Occurred()) SWIG_fail;
28159 }
28160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28161 return resultobj;
28162 fail:
28163 return NULL;
28164 }
28165
28166
28167 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28168 PyObject *resultobj = 0;
28169 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28170 int arg2 ;
28171 wxTimeSpan *result = 0 ;
28172 void *argp1 = 0 ;
28173 int res1 = 0 ;
28174 int val2 ;
28175 int ecode2 = 0 ;
28176 PyObject * obj0 = 0 ;
28177 PyObject * obj1 = 0 ;
28178 char * kwnames[] = {
28179 (char *) "self",(char *) "n", NULL
28180 };
28181
28182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28184 if (!SWIG_IsOK(res1)) {
28185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28186 }
28187 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28188 ecode2 = SWIG_AsVal_int(obj1, &val2);
28189 if (!SWIG_IsOK(ecode2)) {
28190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28191 }
28192 arg2 = static_cast< int >(val2);
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 {
28196 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28197 result = (wxTimeSpan *) &_result_ref;
28198 }
28199 wxPyEndAllowThreads(__tstate);
28200 if (PyErr_Occurred()) SWIG_fail;
28201 }
28202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28210 PyObject *resultobj = 0;
28211 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28212 wxTimeSpan *result = 0 ;
28213 void *argp1 = 0 ;
28214 int res1 = 0 ;
28215 PyObject *swig_obj[1] ;
28216
28217 if (!args) SWIG_fail;
28218 swig_obj[0] = args;
28219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28220 if (!SWIG_IsOK(res1)) {
28221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28222 }
28223 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 {
28227 wxTimeSpan &_result_ref = (arg1)->operator -();
28228 result = (wxTimeSpan *) &_result_ref;
28229 }
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28234 return resultobj;
28235 fail:
28236 return NULL;
28237 }
28238
28239
28240 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28241 PyObject *resultobj = 0;
28242 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28243 wxTimeSpan *arg2 = 0 ;
28244 wxTimeSpan result;
28245 void *argp1 = 0 ;
28246 int res1 = 0 ;
28247 void *argp2 = 0 ;
28248 int res2 = 0 ;
28249 PyObject * obj0 = 0 ;
28250 PyObject * obj1 = 0 ;
28251 char * kwnames[] = {
28252 (char *) "self",(char *) "other", NULL
28253 };
28254
28255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28257 if (!SWIG_IsOK(res1)) {
28258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28259 }
28260 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28261 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28262 if (!SWIG_IsOK(res2)) {
28263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28264 }
28265 if (!argp2) {
28266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28267 }
28268 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28269 {
28270 PyThreadState* __tstate = wxPyBeginAllowThreads();
28271 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28272 wxPyEndAllowThreads(__tstate);
28273 if (PyErr_Occurred()) SWIG_fail;
28274 }
28275 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28285 wxTimeSpan *arg2 = 0 ;
28286 wxTimeSpan result;
28287 void *argp1 = 0 ;
28288 int res1 = 0 ;
28289 void *argp2 = 0 ;
28290 int res2 = 0 ;
28291 PyObject * obj0 = 0 ;
28292 PyObject * obj1 = 0 ;
28293 char * kwnames[] = {
28294 (char *) "self",(char *) "other", NULL
28295 };
28296
28297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28299 if (!SWIG_IsOK(res1)) {
28300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28301 }
28302 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28303 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28304 if (!SWIG_IsOK(res2)) {
28305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28306 }
28307 if (!argp2) {
28308 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28309 }
28310 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28325 PyObject *resultobj = 0;
28326 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28327 int arg2 ;
28328 wxTimeSpan result;
28329 void *argp1 = 0 ;
28330 int res1 = 0 ;
28331 int val2 ;
28332 int ecode2 = 0 ;
28333 PyObject * obj0 = 0 ;
28334 PyObject * obj1 = 0 ;
28335 char * kwnames[] = {
28336 (char *) "self",(char *) "n", NULL
28337 };
28338
28339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28341 if (!SWIG_IsOK(res1)) {
28342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28343 }
28344 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28345 ecode2 = SWIG_AsVal_int(obj1, &val2);
28346 if (!SWIG_IsOK(ecode2)) {
28347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28348 }
28349 arg2 = static_cast< int >(val2);
28350 {
28351 PyThreadState* __tstate = wxPyBeginAllowThreads();
28352 result = wxTimeSpan___mul__(arg1,arg2);
28353 wxPyEndAllowThreads(__tstate);
28354 if (PyErr_Occurred()) SWIG_fail;
28355 }
28356 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28364 PyObject *resultobj = 0;
28365 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28366 int arg2 ;
28367 wxTimeSpan result;
28368 void *argp1 = 0 ;
28369 int res1 = 0 ;
28370 int val2 ;
28371 int ecode2 = 0 ;
28372 PyObject * obj0 = 0 ;
28373 PyObject * obj1 = 0 ;
28374 char * kwnames[] = {
28375 (char *) "self",(char *) "n", NULL
28376 };
28377
28378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28380 if (!SWIG_IsOK(res1)) {
28381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28382 }
28383 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28384 ecode2 = SWIG_AsVal_int(obj1, &val2);
28385 if (!SWIG_IsOK(ecode2)) {
28386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28387 }
28388 arg2 = static_cast< int >(val2);
28389 {
28390 PyThreadState* __tstate = wxPyBeginAllowThreads();
28391 result = wxTimeSpan___rmul__(arg1,arg2);
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28396 return resultobj;
28397 fail:
28398 return NULL;
28399 }
28400
28401
28402 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28403 PyObject *resultobj = 0;
28404 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28405 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28406 bool result;
28407 void *argp1 = 0 ;
28408 int res1 = 0 ;
28409 void *argp2 = 0 ;
28410 int res2 = 0 ;
28411 PyObject * obj0 = 0 ;
28412 PyObject * obj1 = 0 ;
28413 char * kwnames[] = {
28414 (char *) "self",(char *) "other", NULL
28415 };
28416
28417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28419 if (!SWIG_IsOK(res1)) {
28420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28421 }
28422 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28424 if (!SWIG_IsOK(res2)) {
28425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28426 }
28427 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28428 {
28429 PyThreadState* __tstate = wxPyBeginAllowThreads();
28430 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28431 wxPyEndAllowThreads(__tstate);
28432 if (PyErr_Occurred()) SWIG_fail;
28433 }
28434 {
28435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28436 }
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj = 0;
28445 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28446 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28447 bool result;
28448 void *argp1 = 0 ;
28449 int res1 = 0 ;
28450 void *argp2 = 0 ;
28451 int res2 = 0 ;
28452 PyObject * obj0 = 0 ;
28453 PyObject * obj1 = 0 ;
28454 char * kwnames[] = {
28455 (char *) "self",(char *) "other", NULL
28456 };
28457
28458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28460 if (!SWIG_IsOK(res1)) {
28461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28462 }
28463 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28465 if (!SWIG_IsOK(res2)) {
28466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28467 }
28468 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28469 {
28470 PyThreadState* __tstate = wxPyBeginAllowThreads();
28471 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28472 wxPyEndAllowThreads(__tstate);
28473 if (PyErr_Occurred()) SWIG_fail;
28474 }
28475 {
28476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28477 }
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28485 PyObject *resultobj = 0;
28486 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28487 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28488 bool result;
28489 void *argp1 = 0 ;
28490 int res1 = 0 ;
28491 void *argp2 = 0 ;
28492 int res2 = 0 ;
28493 PyObject * obj0 = 0 ;
28494 PyObject * obj1 = 0 ;
28495 char * kwnames[] = {
28496 (char *) "self",(char *) "other", NULL
28497 };
28498
28499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28501 if (!SWIG_IsOK(res1)) {
28502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28503 }
28504 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28505 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28506 if (!SWIG_IsOK(res2)) {
28507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28508 }
28509 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28510 {
28511 PyThreadState* __tstate = wxPyBeginAllowThreads();
28512 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 {
28517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28518 }
28519 return resultobj;
28520 fail:
28521 return NULL;
28522 }
28523
28524
28525 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28526 PyObject *resultobj = 0;
28527 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28528 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28529 bool result;
28530 void *argp1 = 0 ;
28531 int res1 = 0 ;
28532 void *argp2 = 0 ;
28533 int res2 = 0 ;
28534 PyObject * obj0 = 0 ;
28535 PyObject * obj1 = 0 ;
28536 char * kwnames[] = {
28537 (char *) "self",(char *) "other", NULL
28538 };
28539
28540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28542 if (!SWIG_IsOK(res1)) {
28543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28544 }
28545 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28547 if (!SWIG_IsOK(res2)) {
28548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28549 }
28550 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28551 {
28552 PyThreadState* __tstate = wxPyBeginAllowThreads();
28553 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28554 wxPyEndAllowThreads(__tstate);
28555 if (PyErr_Occurred()) SWIG_fail;
28556 }
28557 {
28558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28559 }
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj = 0;
28568 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28569 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28570 bool result;
28571 void *argp1 = 0 ;
28572 int res1 = 0 ;
28573 void *argp2 = 0 ;
28574 int res2 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 PyObject * obj1 = 0 ;
28577 char * kwnames[] = {
28578 (char *) "self",(char *) "other", NULL
28579 };
28580
28581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28583 if (!SWIG_IsOK(res1)) {
28584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28585 }
28586 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28588 if (!SWIG_IsOK(res2)) {
28589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28590 }
28591 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28595 wxPyEndAllowThreads(__tstate);
28596 if (PyErr_Occurred()) SWIG_fail;
28597 }
28598 {
28599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28600 }
28601 return resultobj;
28602 fail:
28603 return NULL;
28604 }
28605
28606
28607 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28608 PyObject *resultobj = 0;
28609 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28610 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28611 bool result;
28612 void *argp1 = 0 ;
28613 int res1 = 0 ;
28614 void *argp2 = 0 ;
28615 int res2 = 0 ;
28616 PyObject * obj0 = 0 ;
28617 PyObject * obj1 = 0 ;
28618 char * kwnames[] = {
28619 (char *) "self",(char *) "other", NULL
28620 };
28621
28622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28624 if (!SWIG_IsOK(res1)) {
28625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28626 }
28627 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28629 if (!SWIG_IsOK(res2)) {
28630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28631 }
28632 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28633 {
28634 PyThreadState* __tstate = wxPyBeginAllowThreads();
28635 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 {
28640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28641 }
28642 return resultobj;
28643 fail:
28644 return NULL;
28645 }
28646
28647
28648 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28649 PyObject *resultobj = 0;
28650 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28651 bool result;
28652 void *argp1 = 0 ;
28653 int res1 = 0 ;
28654 PyObject *swig_obj[1] ;
28655
28656 if (!args) SWIG_fail;
28657 swig_obj[0] = args;
28658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28659 if (!SWIG_IsOK(res1)) {
28660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28661 }
28662 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28663 {
28664 PyThreadState* __tstate = wxPyBeginAllowThreads();
28665 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28666 wxPyEndAllowThreads(__tstate);
28667 if (PyErr_Occurred()) SWIG_fail;
28668 }
28669 {
28670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28671 }
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28679 PyObject *resultobj = 0;
28680 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28681 bool result;
28682 void *argp1 = 0 ;
28683 int res1 = 0 ;
28684 PyObject *swig_obj[1] ;
28685
28686 if (!args) SWIG_fail;
28687 swig_obj[0] = args;
28688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28689 if (!SWIG_IsOK(res1)) {
28690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28691 }
28692 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 {
28700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28701 }
28702 return resultobj;
28703 fail:
28704 return NULL;
28705 }
28706
28707
28708 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28709 PyObject *resultobj = 0;
28710 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28711 bool result;
28712 void *argp1 = 0 ;
28713 int res1 = 0 ;
28714 PyObject *swig_obj[1] ;
28715
28716 if (!args) SWIG_fail;
28717 swig_obj[0] = args;
28718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28719 if (!SWIG_IsOK(res1)) {
28720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28721 }
28722 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 {
28730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28731 }
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj = 0;
28740 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28741 wxTimeSpan *arg2 = 0 ;
28742 bool result;
28743 void *argp1 = 0 ;
28744 int res1 = 0 ;
28745 void *argp2 = 0 ;
28746 int res2 = 0 ;
28747 PyObject * obj0 = 0 ;
28748 PyObject * obj1 = 0 ;
28749 char * kwnames[] = {
28750 (char *) "self",(char *) "ts", NULL
28751 };
28752
28753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28755 if (!SWIG_IsOK(res1)) {
28756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28757 }
28758 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28760 if (!SWIG_IsOK(res2)) {
28761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28762 }
28763 if (!argp2) {
28764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28765 }
28766 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 {
28774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28775 }
28776 return resultobj;
28777 fail:
28778 return NULL;
28779 }
28780
28781
28782 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28783 PyObject *resultobj = 0;
28784 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28785 wxTimeSpan *arg2 = 0 ;
28786 bool result;
28787 void *argp1 = 0 ;
28788 int res1 = 0 ;
28789 void *argp2 = 0 ;
28790 int res2 = 0 ;
28791 PyObject * obj0 = 0 ;
28792 PyObject * obj1 = 0 ;
28793 char * kwnames[] = {
28794 (char *) "self",(char *) "ts", NULL
28795 };
28796
28797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28799 if (!SWIG_IsOK(res1)) {
28800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28801 }
28802 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28803 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28804 if (!SWIG_IsOK(res2)) {
28805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28806 }
28807 if (!argp2) {
28808 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28809 }
28810 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28819 }
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28827 PyObject *resultobj = 0;
28828 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28829 wxTimeSpan *arg2 = 0 ;
28830 bool result;
28831 void *argp1 = 0 ;
28832 int res1 = 0 ;
28833 void *argp2 = 0 ;
28834 int res2 = 0 ;
28835 PyObject * obj0 = 0 ;
28836 PyObject * obj1 = 0 ;
28837 char * kwnames[] = {
28838 (char *) "self",(char *) "t", NULL
28839 };
28840
28841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28843 if (!SWIG_IsOK(res1)) {
28844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28845 }
28846 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28847 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28848 if (!SWIG_IsOK(res2)) {
28849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28850 }
28851 if (!argp2) {
28852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28853 }
28854 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 {
28862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28863 }
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28871 PyObject *resultobj = 0;
28872 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28873 int result;
28874 void *argp1 = 0 ;
28875 int res1 = 0 ;
28876 PyObject *swig_obj[1] ;
28877
28878 if (!args) SWIG_fail;
28879 swig_obj[0] = args;
28880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28881 if (!SWIG_IsOK(res1)) {
28882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28883 }
28884 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28885 {
28886 PyThreadState* __tstate = wxPyBeginAllowThreads();
28887 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 resultobj = SWIG_From_int(static_cast< int >(result));
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28899 PyObject *resultobj = 0;
28900 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28901 int result;
28902 void *argp1 = 0 ;
28903 int res1 = 0 ;
28904 PyObject *swig_obj[1] ;
28905
28906 if (!args) SWIG_fail;
28907 swig_obj[0] = args;
28908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28909 if (!SWIG_IsOK(res1)) {
28910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28911 }
28912 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28913 {
28914 PyThreadState* __tstate = wxPyBeginAllowThreads();
28915 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28916 wxPyEndAllowThreads(__tstate);
28917 if (PyErr_Occurred()) SWIG_fail;
28918 }
28919 resultobj = SWIG_From_int(static_cast< int >(result));
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28927 PyObject *resultobj = 0;
28928 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28929 int result;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 PyObject *swig_obj[1] ;
28933
28934 if (!args) SWIG_fail;
28935 swig_obj[0] = args;
28936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28937 if (!SWIG_IsOK(res1)) {
28938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28939 }
28940 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 resultobj = SWIG_From_int(static_cast< int >(result));
28948 return resultobj;
28949 fail:
28950 return NULL;
28951 }
28952
28953
28954 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28955 PyObject *resultobj = 0;
28956 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28957 int result;
28958 void *argp1 = 0 ;
28959 int res1 = 0 ;
28960 PyObject *swig_obj[1] ;
28961
28962 if (!args) SWIG_fail;
28963 swig_obj[0] = args;
28964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28965 if (!SWIG_IsOK(res1)) {
28966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28967 }
28968 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28969 {
28970 PyThreadState* __tstate = wxPyBeginAllowThreads();
28971 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28972 wxPyEndAllowThreads(__tstate);
28973 if (PyErr_Occurred()) SWIG_fail;
28974 }
28975 resultobj = SWIG_From_int(static_cast< int >(result));
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28983 PyObject *resultobj = 0;
28984 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28985 wxLongLong result;
28986 void *argp1 = 0 ;
28987 int res1 = 0 ;
28988 PyObject *swig_obj[1] ;
28989
28990 if (!args) SWIG_fail;
28991 swig_obj[0] = args;
28992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28993 if (!SWIG_IsOK(res1)) {
28994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28995 }
28996 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 result = ((wxTimeSpan const *)arg1)->GetSeconds();
29000 wxPyEndAllowThreads(__tstate);
29001 if (PyErr_Occurred()) SWIG_fail;
29002 }
29003 {
29004 PyObject *hi, *lo, *shifter, *shifted;
29005 hi = PyLong_FromLong( (&result)->GetHi() );
29006 lo = PyLong_FromLong( (&result)->GetLo() );
29007 shifter = PyLong_FromLong(32);
29008 shifted = PyNumber_Lshift(hi, shifter);
29009 resultobj = PyNumber_Or(shifted, lo);
29010 Py_DECREF(hi);
29011 Py_DECREF(lo);
29012 Py_DECREF(shifter);
29013 Py_DECREF(shifted);
29014 }
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29022 PyObject *resultobj = 0;
29023 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29024 wxLongLong result;
29025 void *argp1 = 0 ;
29026 int res1 = 0 ;
29027 PyObject *swig_obj[1] ;
29028
29029 if (!args) SWIG_fail;
29030 swig_obj[0] = args;
29031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29032 if (!SWIG_IsOK(res1)) {
29033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29034 }
29035 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29039 wxPyEndAllowThreads(__tstate);
29040 if (PyErr_Occurred()) SWIG_fail;
29041 }
29042 {
29043 PyObject *hi, *lo, *shifter, *shifted;
29044 hi = PyLong_FromLong( (&result)->GetHi() );
29045 lo = PyLong_FromLong( (&result)->GetLo() );
29046 shifter = PyLong_FromLong(32);
29047 shifted = PyNumber_Lshift(hi, shifter);
29048 resultobj = PyNumber_Or(shifted, lo);
29049 Py_DECREF(hi);
29050 Py_DECREF(lo);
29051 Py_DECREF(shifter);
29052 Py_DECREF(shifted);
29053 }
29054 return resultobj;
29055 fail:
29056 return NULL;
29057 }
29058
29059
29060 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29061 PyObject *resultobj = 0;
29062 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29063 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29064 wxString *arg2 = (wxString *) &arg2_defvalue ;
29065 wxString result;
29066 void *argp1 = 0 ;
29067 int res1 = 0 ;
29068 bool temp2 = false ;
29069 PyObject * obj0 = 0 ;
29070 PyObject * obj1 = 0 ;
29071 char * kwnames[] = {
29072 (char *) "self",(char *) "format", NULL
29073 };
29074
29075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29077 if (!SWIG_IsOK(res1)) {
29078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29079 }
29080 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29081 if (obj1) {
29082 {
29083 arg2 = wxString_in_helper(obj1);
29084 if (arg2 == NULL) SWIG_fail;
29085 temp2 = true;
29086 }
29087 }
29088 {
29089 PyThreadState* __tstate = wxPyBeginAllowThreads();
29090 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29091 wxPyEndAllowThreads(__tstate);
29092 if (PyErr_Occurred()) SWIG_fail;
29093 }
29094 {
29095 #if wxUSE_UNICODE
29096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29097 #else
29098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29099 #endif
29100 }
29101 {
29102 if (temp2)
29103 delete arg2;
29104 }
29105 return resultobj;
29106 fail:
29107 {
29108 if (temp2)
29109 delete arg2;
29110 }
29111 return NULL;
29112 }
29113
29114
29115 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29116 PyObject *obj;
29117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29118 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
29119 return SWIG_Py_Void();
29120 }
29121
29122 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29123 return SWIG_Python_InitShadowInstance(args);
29124 }
29125
29126 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj = 0;
29128 int arg1 = (int) 0 ;
29129 int arg2 = (int) 0 ;
29130 int arg3 = (int) 0 ;
29131 int arg4 = (int) 0 ;
29132 wxDateSpan *result = 0 ;
29133 int val1 ;
29134 int ecode1 = 0 ;
29135 int val2 ;
29136 int ecode2 = 0 ;
29137 int val3 ;
29138 int ecode3 = 0 ;
29139 int val4 ;
29140 int ecode4 = 0 ;
29141 PyObject * obj0 = 0 ;
29142 PyObject * obj1 = 0 ;
29143 PyObject * obj2 = 0 ;
29144 PyObject * obj3 = 0 ;
29145 char * kwnames[] = {
29146 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
29147 };
29148
29149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29150 if (obj0) {
29151 ecode1 = SWIG_AsVal_int(obj0, &val1);
29152 if (!SWIG_IsOK(ecode1)) {
29153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
29154 }
29155 arg1 = static_cast< int >(val1);
29156 }
29157 if (obj1) {
29158 ecode2 = SWIG_AsVal_int(obj1, &val2);
29159 if (!SWIG_IsOK(ecode2)) {
29160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
29161 }
29162 arg2 = static_cast< int >(val2);
29163 }
29164 if (obj2) {
29165 ecode3 = SWIG_AsVal_int(obj2, &val3);
29166 if (!SWIG_IsOK(ecode3)) {
29167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
29168 }
29169 arg3 = static_cast< int >(val3);
29170 }
29171 if (obj3) {
29172 ecode4 = SWIG_AsVal_int(obj3, &val4);
29173 if (!SWIG_IsOK(ecode4)) {
29174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
29175 }
29176 arg4 = static_cast< int >(val4);
29177 }
29178 {
29179 PyThreadState* __tstate = wxPyBeginAllowThreads();
29180 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29185 return resultobj;
29186 fail:
29187 return NULL;
29188 }
29189
29190
29191 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29192 PyObject *resultobj = 0;
29193 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29194 void *argp1 = 0 ;
29195 int res1 = 0 ;
29196 PyObject *swig_obj[1] ;
29197
29198 if (!args) SWIG_fail;
29199 swig_obj[0] = args;
29200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29201 if (!SWIG_IsOK(res1)) {
29202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29203 }
29204 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 delete arg1;
29208
29209 wxPyEndAllowThreads(__tstate);
29210 if (PyErr_Occurred()) SWIG_fail;
29211 }
29212 resultobj = SWIG_Py_Void();
29213 return resultobj;
29214 fail:
29215 return NULL;
29216 }
29217
29218
29219 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29220 PyObject *resultobj = 0;
29221 int arg1 ;
29222 wxDateSpan result;
29223 int val1 ;
29224 int ecode1 = 0 ;
29225 PyObject * obj0 = 0 ;
29226 char * kwnames[] = {
29227 (char *) "days", NULL
29228 };
29229
29230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29231 ecode1 = SWIG_AsVal_int(obj0, &val1);
29232 if (!SWIG_IsOK(ecode1)) {
29233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29234 }
29235 arg1 = static_cast< int >(val1);
29236 {
29237 PyThreadState* __tstate = wxPyBeginAllowThreads();
29238 result = wxDateSpan::Days(arg1);
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29243 return resultobj;
29244 fail:
29245 return NULL;
29246 }
29247
29248
29249 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29250 PyObject *resultobj = 0;
29251 wxDateSpan result;
29252
29253 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29254 {
29255 PyThreadState* __tstate = wxPyBeginAllowThreads();
29256 result = wxDateSpan::Day();
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj = 0;
29269 int arg1 ;
29270 wxDateSpan result;
29271 int val1 ;
29272 int ecode1 = 0 ;
29273 PyObject * obj0 = 0 ;
29274 char * kwnames[] = {
29275 (char *) "weeks", NULL
29276 };
29277
29278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29279 ecode1 = SWIG_AsVal_int(obj0, &val1);
29280 if (!SWIG_IsOK(ecode1)) {
29281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29282 }
29283 arg1 = static_cast< int >(val1);
29284 {
29285 PyThreadState* __tstate = wxPyBeginAllowThreads();
29286 result = wxDateSpan::Weeks(arg1);
29287 wxPyEndAllowThreads(__tstate);
29288 if (PyErr_Occurred()) SWIG_fail;
29289 }
29290 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29291 return resultobj;
29292 fail:
29293 return NULL;
29294 }
29295
29296
29297 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29298 PyObject *resultobj = 0;
29299 wxDateSpan result;
29300
29301 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29302 {
29303 PyThreadState* __tstate = wxPyBeginAllowThreads();
29304 result = wxDateSpan::Week();
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29316 PyObject *resultobj = 0;
29317 int arg1 ;
29318 wxDateSpan result;
29319 int val1 ;
29320 int ecode1 = 0 ;
29321 PyObject * obj0 = 0 ;
29322 char * kwnames[] = {
29323 (char *) "mon", NULL
29324 };
29325
29326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29327 ecode1 = SWIG_AsVal_int(obj0, &val1);
29328 if (!SWIG_IsOK(ecode1)) {
29329 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29330 }
29331 arg1 = static_cast< int >(val1);
29332 {
29333 PyThreadState* __tstate = wxPyBeginAllowThreads();
29334 result = wxDateSpan::Months(arg1);
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29346 PyObject *resultobj = 0;
29347 wxDateSpan result;
29348
29349 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 result = wxDateSpan::Month();
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 int arg1 ;
29366 wxDateSpan result;
29367 int val1 ;
29368 int ecode1 = 0 ;
29369 PyObject * obj0 = 0 ;
29370 char * kwnames[] = {
29371 (char *) "years", NULL
29372 };
29373
29374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29375 ecode1 = SWIG_AsVal_int(obj0, &val1);
29376 if (!SWIG_IsOK(ecode1)) {
29377 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29378 }
29379 arg1 = static_cast< int >(val1);
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 result = wxDateSpan::Years(arg1);
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29394 PyObject *resultobj = 0;
29395 wxDateSpan result;
29396
29397 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 result = wxDateSpan::Year();
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29405 return resultobj;
29406 fail:
29407 return NULL;
29408 }
29409
29410
29411 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29412 PyObject *resultobj = 0;
29413 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29414 int arg2 ;
29415 wxDateSpan *result = 0 ;
29416 void *argp1 = 0 ;
29417 int res1 = 0 ;
29418 int val2 ;
29419 int ecode2 = 0 ;
29420 PyObject * obj0 = 0 ;
29421 PyObject * obj1 = 0 ;
29422 char * kwnames[] = {
29423 (char *) "self",(char *) "n", NULL
29424 };
29425
29426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29428 if (!SWIG_IsOK(res1)) {
29429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29430 }
29431 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29432 ecode2 = SWIG_AsVal_int(obj1, &val2);
29433 if (!SWIG_IsOK(ecode2)) {
29434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29435 }
29436 arg2 = static_cast< int >(val2);
29437 {
29438 PyThreadState* __tstate = wxPyBeginAllowThreads();
29439 {
29440 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29441 result = (wxDateSpan *) &_result_ref;
29442 }
29443 wxPyEndAllowThreads(__tstate);
29444 if (PyErr_Occurred()) SWIG_fail;
29445 }
29446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29447 return resultobj;
29448 fail:
29449 return NULL;
29450 }
29451
29452
29453 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29454 PyObject *resultobj = 0;
29455 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29456 int arg2 ;
29457 wxDateSpan *result = 0 ;
29458 void *argp1 = 0 ;
29459 int res1 = 0 ;
29460 int val2 ;
29461 int ecode2 = 0 ;
29462 PyObject * obj0 = 0 ;
29463 PyObject * obj1 = 0 ;
29464 char * kwnames[] = {
29465 (char *) "self",(char *) "n", NULL
29466 };
29467
29468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29470 if (!SWIG_IsOK(res1)) {
29471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29472 }
29473 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29474 ecode2 = SWIG_AsVal_int(obj1, &val2);
29475 if (!SWIG_IsOK(ecode2)) {
29476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29477 }
29478 arg2 = static_cast< int >(val2);
29479 {
29480 PyThreadState* __tstate = wxPyBeginAllowThreads();
29481 {
29482 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29483 result = (wxDateSpan *) &_result_ref;
29484 }
29485 wxPyEndAllowThreads(__tstate);
29486 if (PyErr_Occurred()) SWIG_fail;
29487 }
29488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29489 return resultobj;
29490 fail:
29491 return NULL;
29492 }
29493
29494
29495 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29496 PyObject *resultobj = 0;
29497 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29498 int arg2 ;
29499 wxDateSpan *result = 0 ;
29500 void *argp1 = 0 ;
29501 int res1 = 0 ;
29502 int val2 ;
29503 int ecode2 = 0 ;
29504 PyObject * obj0 = 0 ;
29505 PyObject * obj1 = 0 ;
29506 char * kwnames[] = {
29507 (char *) "self",(char *) "n", NULL
29508 };
29509
29510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29512 if (!SWIG_IsOK(res1)) {
29513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29514 }
29515 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29516 ecode2 = SWIG_AsVal_int(obj1, &val2);
29517 if (!SWIG_IsOK(ecode2)) {
29518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29519 }
29520 arg2 = static_cast< int >(val2);
29521 {
29522 PyThreadState* __tstate = wxPyBeginAllowThreads();
29523 {
29524 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29525 result = (wxDateSpan *) &_result_ref;
29526 }
29527 wxPyEndAllowThreads(__tstate);
29528 if (PyErr_Occurred()) SWIG_fail;
29529 }
29530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29531 return resultobj;
29532 fail:
29533 return NULL;
29534 }
29535
29536
29537 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29538 PyObject *resultobj = 0;
29539 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29540 int arg2 ;
29541 wxDateSpan *result = 0 ;
29542 void *argp1 = 0 ;
29543 int res1 = 0 ;
29544 int val2 ;
29545 int ecode2 = 0 ;
29546 PyObject * obj0 = 0 ;
29547 PyObject * obj1 = 0 ;
29548 char * kwnames[] = {
29549 (char *) "self",(char *) "n", NULL
29550 };
29551
29552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29554 if (!SWIG_IsOK(res1)) {
29555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29556 }
29557 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29558 ecode2 = SWIG_AsVal_int(obj1, &val2);
29559 if (!SWIG_IsOK(ecode2)) {
29560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29561 }
29562 arg2 = static_cast< int >(val2);
29563 {
29564 PyThreadState* __tstate = wxPyBeginAllowThreads();
29565 {
29566 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29567 result = (wxDateSpan *) &_result_ref;
29568 }
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29580 PyObject *resultobj = 0;
29581 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29582 int result;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 PyObject *swig_obj[1] ;
29586
29587 if (!args) SWIG_fail;
29588 swig_obj[0] = args;
29589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29590 if (!SWIG_IsOK(res1)) {
29591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29592 }
29593 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29594 {
29595 PyThreadState* __tstate = wxPyBeginAllowThreads();
29596 result = (int)((wxDateSpan const *)arg1)->GetYears();
29597 wxPyEndAllowThreads(__tstate);
29598 if (PyErr_Occurred()) SWIG_fail;
29599 }
29600 resultobj = SWIG_From_int(static_cast< int >(result));
29601 return resultobj;
29602 fail:
29603 return NULL;
29604 }
29605
29606
29607 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29608 PyObject *resultobj = 0;
29609 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29610 int result;
29611 void *argp1 = 0 ;
29612 int res1 = 0 ;
29613 PyObject *swig_obj[1] ;
29614
29615 if (!args) SWIG_fail;
29616 swig_obj[0] = args;
29617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29618 if (!SWIG_IsOK(res1)) {
29619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29620 }
29621 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 resultobj = SWIG_From_int(static_cast< int >(result));
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29636 PyObject *resultobj = 0;
29637 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29638 int result;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 PyObject *swig_obj[1] ;
29642
29643 if (!args) SWIG_fail;
29644 swig_obj[0] = args;
29645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29648 }
29649 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 resultobj = SWIG_From_int(static_cast< int >(result));
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29664 PyObject *resultobj = 0;
29665 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29666 int result;
29667 void *argp1 = 0 ;
29668 int res1 = 0 ;
29669 PyObject *swig_obj[1] ;
29670
29671 if (!args) SWIG_fail;
29672 swig_obj[0] = args;
29673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29674 if (!SWIG_IsOK(res1)) {
29675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29676 }
29677 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = (int)((wxDateSpan const *)arg1)->GetDays();
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 resultobj = SWIG_From_int(static_cast< int >(result));
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29692 PyObject *resultobj = 0;
29693 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29694 int result;
29695 void *argp1 = 0 ;
29696 int res1 = 0 ;
29697 PyObject *swig_obj[1] ;
29698
29699 if (!args) SWIG_fail;
29700 swig_obj[0] = args;
29701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29702 if (!SWIG_IsOK(res1)) {
29703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29704 }
29705 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 resultobj = SWIG_From_int(static_cast< int >(result));
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29720 PyObject *resultobj = 0;
29721 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29722 wxDateSpan *arg2 = 0 ;
29723 wxDateSpan *result = 0 ;
29724 void *argp1 = 0 ;
29725 int res1 = 0 ;
29726 void *argp2 = 0 ;
29727 int res2 = 0 ;
29728 PyObject * obj0 = 0 ;
29729 PyObject * obj1 = 0 ;
29730 char * kwnames[] = {
29731 (char *) "self",(char *) "other", NULL
29732 };
29733
29734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29736 if (!SWIG_IsOK(res1)) {
29737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29738 }
29739 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29740 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29741 if (!SWIG_IsOK(res2)) {
29742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29743 }
29744 if (!argp2) {
29745 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29746 }
29747 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 {
29751 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29752 result = (wxDateSpan *) &_result_ref;
29753 }
29754 wxPyEndAllowThreads(__tstate);
29755 if (PyErr_Occurred()) SWIG_fail;
29756 }
29757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29758 return resultobj;
29759 fail:
29760 return NULL;
29761 }
29762
29763
29764 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29765 PyObject *resultobj = 0;
29766 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29767 wxDateSpan *arg2 = 0 ;
29768 wxDateSpan *result = 0 ;
29769 void *argp1 = 0 ;
29770 int res1 = 0 ;
29771 void *argp2 = 0 ;
29772 int res2 = 0 ;
29773 PyObject * obj0 = 0 ;
29774 PyObject * obj1 = 0 ;
29775 char * kwnames[] = {
29776 (char *) "self",(char *) "other", NULL
29777 };
29778
29779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29781 if (!SWIG_IsOK(res1)) {
29782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29783 }
29784 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29786 if (!SWIG_IsOK(res2)) {
29787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29788 }
29789 if (!argp2) {
29790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29791 }
29792 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29793 {
29794 PyThreadState* __tstate = wxPyBeginAllowThreads();
29795 {
29796 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29797 result = (wxDateSpan *) &_result_ref;
29798 }
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29810 PyObject *resultobj = 0;
29811 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29812 wxDateSpan *result = 0 ;
29813 void *argp1 = 0 ;
29814 int res1 = 0 ;
29815 PyObject *swig_obj[1] ;
29816
29817 if (!args) SWIG_fail;
29818 swig_obj[0] = args;
29819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29820 if (!SWIG_IsOK(res1)) {
29821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29822 }
29823 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 {
29827 wxDateSpan &_result_ref = (arg1)->Neg();
29828 result = (wxDateSpan *) &_result_ref;
29829 }
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29834 return resultobj;
29835 fail:
29836 return NULL;
29837 }
29838
29839
29840 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29841 PyObject *resultobj = 0;
29842 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29843 int arg2 ;
29844 wxDateSpan *result = 0 ;
29845 void *argp1 = 0 ;
29846 int res1 = 0 ;
29847 int val2 ;
29848 int ecode2 = 0 ;
29849 PyObject * obj0 = 0 ;
29850 PyObject * obj1 = 0 ;
29851 char * kwnames[] = {
29852 (char *) "self",(char *) "factor", NULL
29853 };
29854
29855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29857 if (!SWIG_IsOK(res1)) {
29858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29859 }
29860 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29861 ecode2 = SWIG_AsVal_int(obj1, &val2);
29862 if (!SWIG_IsOK(ecode2)) {
29863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29864 }
29865 arg2 = static_cast< int >(val2);
29866 {
29867 PyThreadState* __tstate = wxPyBeginAllowThreads();
29868 {
29869 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29870 result = (wxDateSpan *) &_result_ref;
29871 }
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29876 return resultobj;
29877 fail:
29878 return NULL;
29879 }
29880
29881
29882 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29883 PyObject *resultobj = 0;
29884 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29885 wxDateSpan *arg2 = 0 ;
29886 wxDateSpan *result = 0 ;
29887 void *argp1 = 0 ;
29888 int res1 = 0 ;
29889 void *argp2 = 0 ;
29890 int res2 = 0 ;
29891 PyObject * obj0 = 0 ;
29892 PyObject * obj1 = 0 ;
29893 char * kwnames[] = {
29894 (char *) "self",(char *) "other", NULL
29895 };
29896
29897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29899 if (!SWIG_IsOK(res1)) {
29900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29901 }
29902 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29903 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29904 if (!SWIG_IsOK(res2)) {
29905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29906 }
29907 if (!argp2) {
29908 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29909 }
29910 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29911 {
29912 PyThreadState* __tstate = wxPyBeginAllowThreads();
29913 {
29914 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29915 result = (wxDateSpan *) &_result_ref;
29916 }
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj = 0;
29929 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29930 wxDateSpan *arg2 = 0 ;
29931 wxDateSpan *result = 0 ;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 void *argp2 = 0 ;
29935 int res2 = 0 ;
29936 PyObject * obj0 = 0 ;
29937 PyObject * obj1 = 0 ;
29938 char * kwnames[] = {
29939 (char *) "self",(char *) "other", NULL
29940 };
29941
29942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29944 if (!SWIG_IsOK(res1)) {
29945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29946 }
29947 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29949 if (!SWIG_IsOK(res2)) {
29950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29951 }
29952 if (!argp2) {
29953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29954 }
29955 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 {
29959 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29960 result = (wxDateSpan *) &_result_ref;
29961 }
29962 wxPyEndAllowThreads(__tstate);
29963 if (PyErr_Occurred()) SWIG_fail;
29964 }
29965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29966 return resultobj;
29967 fail:
29968 return NULL;
29969 }
29970
29971
29972 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29973 PyObject *resultobj = 0;
29974 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29975 wxDateSpan *result = 0 ;
29976 void *argp1 = 0 ;
29977 int res1 = 0 ;
29978 PyObject *swig_obj[1] ;
29979
29980 if (!args) SWIG_fail;
29981 swig_obj[0] = args;
29982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29983 if (!SWIG_IsOK(res1)) {
29984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29985 }
29986 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 {
29990 wxDateSpan &_result_ref = (arg1)->operator -();
29991 result = (wxDateSpan *) &_result_ref;
29992 }
29993 wxPyEndAllowThreads(__tstate);
29994 if (PyErr_Occurred()) SWIG_fail;
29995 }
29996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29997 return resultobj;
29998 fail:
29999 return NULL;
30000 }
30001
30002
30003 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30004 PyObject *resultobj = 0;
30005 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30006 int arg2 ;
30007 wxDateSpan *result = 0 ;
30008 void *argp1 = 0 ;
30009 int res1 = 0 ;
30010 int val2 ;
30011 int ecode2 = 0 ;
30012 PyObject * obj0 = 0 ;
30013 PyObject * obj1 = 0 ;
30014 char * kwnames[] = {
30015 (char *) "self",(char *) "factor", NULL
30016 };
30017
30018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30020 if (!SWIG_IsOK(res1)) {
30021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30022 }
30023 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30024 ecode2 = SWIG_AsVal_int(obj1, &val2);
30025 if (!SWIG_IsOK(ecode2)) {
30026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30027 }
30028 arg2 = static_cast< int >(val2);
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 {
30032 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30033 result = (wxDateSpan *) &_result_ref;
30034 }
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30046 PyObject *resultobj = 0;
30047 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30048 wxDateSpan *arg2 = 0 ;
30049 wxDateSpan result;
30050 void *argp1 = 0 ;
30051 int res1 = 0 ;
30052 void *argp2 = 0 ;
30053 int res2 = 0 ;
30054 PyObject * obj0 = 0 ;
30055 PyObject * obj1 = 0 ;
30056 char * kwnames[] = {
30057 (char *) "self",(char *) "other", NULL
30058 };
30059
30060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30062 if (!SWIG_IsOK(res1)) {
30063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30064 }
30065 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30066 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30067 if (!SWIG_IsOK(res2)) {
30068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30069 }
30070 if (!argp2) {
30071 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30072 }
30073 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30074 {
30075 PyThreadState* __tstate = wxPyBeginAllowThreads();
30076 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30077 wxPyEndAllowThreads(__tstate);
30078 if (PyErr_Occurred()) SWIG_fail;
30079 }
30080 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30081 return resultobj;
30082 fail:
30083 return NULL;
30084 }
30085
30086
30087 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30088 PyObject *resultobj = 0;
30089 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30090 wxDateSpan *arg2 = 0 ;
30091 wxDateSpan result;
30092 void *argp1 = 0 ;
30093 int res1 = 0 ;
30094 void *argp2 = 0 ;
30095 int res2 = 0 ;
30096 PyObject * obj0 = 0 ;
30097 PyObject * obj1 = 0 ;
30098 char * kwnames[] = {
30099 (char *) "self",(char *) "other", NULL
30100 };
30101
30102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30104 if (!SWIG_IsOK(res1)) {
30105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30106 }
30107 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30109 if (!SWIG_IsOK(res2)) {
30110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30111 }
30112 if (!argp2) {
30113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30114 }
30115 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30116 {
30117 PyThreadState* __tstate = wxPyBeginAllowThreads();
30118 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30123 return resultobj;
30124 fail:
30125 return NULL;
30126 }
30127
30128
30129 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30130 PyObject *resultobj = 0;
30131 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30132 int arg2 ;
30133 wxDateSpan result;
30134 void *argp1 = 0 ;
30135 int res1 = 0 ;
30136 int val2 ;
30137 int ecode2 = 0 ;
30138 PyObject * obj0 = 0 ;
30139 PyObject * obj1 = 0 ;
30140 char * kwnames[] = {
30141 (char *) "self",(char *) "n", NULL
30142 };
30143
30144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
30145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30146 if (!SWIG_IsOK(res1)) {
30147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30148 }
30149 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30150 ecode2 = SWIG_AsVal_int(obj1, &val2);
30151 if (!SWIG_IsOK(ecode2)) {
30152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
30153 }
30154 arg2 = static_cast< int >(val2);
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = wxDateSpan___mul__(arg1,arg2);
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30169 PyObject *resultobj = 0;
30170 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30171 int arg2 ;
30172 wxDateSpan result;
30173 void *argp1 = 0 ;
30174 int res1 = 0 ;
30175 int val2 ;
30176 int ecode2 = 0 ;
30177 PyObject * obj0 = 0 ;
30178 PyObject * obj1 = 0 ;
30179 char * kwnames[] = {
30180 (char *) "self",(char *) "n", NULL
30181 };
30182
30183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30185 if (!SWIG_IsOK(res1)) {
30186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30187 }
30188 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30189 ecode2 = SWIG_AsVal_int(obj1, &val2);
30190 if (!SWIG_IsOK(ecode2)) {
30191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30192 }
30193 arg2 = static_cast< int >(val2);
30194 {
30195 PyThreadState* __tstate = wxPyBeginAllowThreads();
30196 result = wxDateSpan___rmul__(arg1,arg2);
30197 wxPyEndAllowThreads(__tstate);
30198 if (PyErr_Occurred()) SWIG_fail;
30199 }
30200 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30201 return resultobj;
30202 fail:
30203 return NULL;
30204 }
30205
30206
30207 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj = 0;
30209 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30210 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30211 bool result;
30212 void *argp1 = 0 ;
30213 int res1 = 0 ;
30214 void *argp2 = 0 ;
30215 int res2 = 0 ;
30216 PyObject * obj0 = 0 ;
30217 PyObject * obj1 = 0 ;
30218 char * kwnames[] = {
30219 (char *) "self",(char *) "other", NULL
30220 };
30221
30222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30224 if (!SWIG_IsOK(res1)) {
30225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30226 }
30227 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30229 if (!SWIG_IsOK(res2)) {
30230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30231 }
30232 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 {
30240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30241 }
30242 return resultobj;
30243 fail:
30244 return NULL;
30245 }
30246
30247
30248 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30249 PyObject *resultobj = 0;
30250 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30251 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30252 bool result;
30253 void *argp1 = 0 ;
30254 int res1 = 0 ;
30255 void *argp2 = 0 ;
30256 int res2 = 0 ;
30257 PyObject * obj0 = 0 ;
30258 PyObject * obj1 = 0 ;
30259 char * kwnames[] = {
30260 (char *) "self",(char *) "other", NULL
30261 };
30262
30263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30265 if (!SWIG_IsOK(res1)) {
30266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30267 }
30268 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30270 if (!SWIG_IsOK(res2)) {
30271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30272 }
30273 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 {
30281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30282 }
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30290 PyObject *obj;
30291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30292 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30293 return SWIG_Py_Void();
30294 }
30295
30296 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30297 return SWIG_Python_InitShadowInstance(args);
30298 }
30299
30300 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30301 PyObject *resultobj = 0;
30302 long result;
30303
30304 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30305 {
30306 PyThreadState* __tstate = wxPyBeginAllowThreads();
30307 result = (long)wxGetLocalTime();
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 resultobj = SWIG_From_long(static_cast< long >(result));
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30319 PyObject *resultobj = 0;
30320 long result;
30321
30322 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (long)wxGetUTCTime();
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 resultobj = SWIG_From_long(static_cast< long >(result));
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30337 PyObject *resultobj = 0;
30338 long result;
30339
30340 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30341 {
30342 PyThreadState* __tstate = wxPyBeginAllowThreads();
30343 result = (long)wxGetCurrentTime();
30344 wxPyEndAllowThreads(__tstate);
30345 if (PyErr_Occurred()) SWIG_fail;
30346 }
30347 resultobj = SWIG_From_long(static_cast< long >(result));
30348 return resultobj;
30349 fail:
30350 return NULL;
30351 }
30352
30353
30354 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30355 PyObject *resultobj = 0;
30356 wxLongLong result;
30357
30358 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30359 {
30360 PyThreadState* __tstate = wxPyBeginAllowThreads();
30361 result = wxGetLocalTimeMillis();
30362 wxPyEndAllowThreads(__tstate);
30363 if (PyErr_Occurred()) SWIG_fail;
30364 }
30365 {
30366 PyObject *hi, *lo, *shifter, *shifted;
30367 hi = PyLong_FromLong( (&result)->GetHi() );
30368 lo = PyLong_FromLong( (&result)->GetLo() );
30369 shifter = PyLong_FromLong(32);
30370 shifted = PyNumber_Lshift(hi, shifter);
30371 resultobj = PyNumber_Or(shifted, lo);
30372 Py_DECREF(hi);
30373 Py_DECREF(lo);
30374 Py_DECREF(shifter);
30375 Py_DECREF(shifted);
30376 }
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30384 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30385 return 1;
30386 }
30387
30388
30389 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30390 PyObject *pyobj = 0;
30391
30392 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30393 return pyobj;
30394 }
30395
30396
30397 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30398 PyObject *resultobj = 0;
30399 wxDataFormatId arg1 ;
30400 wxDataFormat *result = 0 ;
30401 int val1 ;
30402 int ecode1 = 0 ;
30403 PyObject * obj0 = 0 ;
30404 char * kwnames[] = {
30405 (char *) "type", NULL
30406 };
30407
30408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30409 ecode1 = SWIG_AsVal_int(obj0, &val1);
30410 if (!SWIG_IsOK(ecode1)) {
30411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30412 }
30413 arg1 = static_cast< wxDataFormatId >(val1);
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 result = (wxDataFormat *)new wxDataFormat(arg1);
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj = 0;
30429 wxString *arg1 = 0 ;
30430 wxDataFormat *result = 0 ;
30431 bool temp1 = false ;
30432 PyObject * obj0 = 0 ;
30433 char * kwnames[] = {
30434 (char *) "format", NULL
30435 };
30436
30437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30438 {
30439 arg1 = wxString_in_helper(obj0);
30440 if (arg1 == NULL) SWIG_fail;
30441 temp1 = true;
30442 }
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30450 {
30451 if (temp1)
30452 delete arg1;
30453 }
30454 return resultobj;
30455 fail:
30456 {
30457 if (temp1)
30458 delete arg1;
30459 }
30460 return NULL;
30461 }
30462
30463
30464 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30465 PyObject *resultobj = 0;
30466 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30467 void *argp1 = 0 ;
30468 int res1 = 0 ;
30469 PyObject *swig_obj[1] ;
30470
30471 if (!args) SWIG_fail;
30472 swig_obj[0] = args;
30473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30474 if (!SWIG_IsOK(res1)) {
30475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30476 }
30477 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30478 {
30479 PyThreadState* __tstate = wxPyBeginAllowThreads();
30480 delete arg1;
30481
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 resultobj = SWIG_Py_Void();
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30493 PyObject *resultobj = 0;
30494 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30495 wxDataFormatId arg2 ;
30496 bool result;
30497 void *argp1 = 0 ;
30498 int res1 = 0 ;
30499 int val2 ;
30500 int ecode2 = 0 ;
30501
30502 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30504 if (!SWIG_IsOK(res1)) {
30505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30506 }
30507 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30508 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30509 if (!SWIG_IsOK(ecode2)) {
30510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30511 }
30512 arg2 = static_cast< wxDataFormatId >(val2);
30513 {
30514 PyThreadState* __tstate = wxPyBeginAllowThreads();
30515 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30516 wxPyEndAllowThreads(__tstate);
30517 if (PyErr_Occurred()) SWIG_fail;
30518 }
30519 {
30520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30521 }
30522 return resultobj;
30523 fail:
30524 return NULL;
30525 }
30526
30527
30528 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30529 PyObject *resultobj = 0;
30530 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30531 wxDataFormatId arg2 ;
30532 bool result;
30533 void *argp1 = 0 ;
30534 int res1 = 0 ;
30535 int val2 ;
30536 int ecode2 = 0 ;
30537
30538 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30540 if (!SWIG_IsOK(res1)) {
30541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30542 }
30543 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30544 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30545 if (!SWIG_IsOK(ecode2)) {
30546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30547 }
30548 arg2 = static_cast< wxDataFormatId >(val2);
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30552 wxPyEndAllowThreads(__tstate);
30553 if (PyErr_Occurred()) SWIG_fail;
30554 }
30555 {
30556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30557 }
30558 return resultobj;
30559 fail:
30560 return NULL;
30561 }
30562
30563
30564 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30565 PyObject *resultobj = 0;
30566 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30567 wxDataFormat *arg2 = 0 ;
30568 bool result;
30569 void *argp1 = 0 ;
30570 int res1 = 0 ;
30571 void *argp2 = 0 ;
30572 int res2 = 0 ;
30573
30574 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30576 if (!SWIG_IsOK(res1)) {
30577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30578 }
30579 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30580 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30581 if (!SWIG_IsOK(res2)) {
30582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30583 }
30584 if (!argp2) {
30585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30586 }
30587 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30588 {
30589 PyThreadState* __tstate = wxPyBeginAllowThreads();
30590 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30591 wxPyEndAllowThreads(__tstate);
30592 if (PyErr_Occurred()) SWIG_fail;
30593 }
30594 {
30595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30596 }
30597 return resultobj;
30598 fail:
30599 return NULL;
30600 }
30601
30602
30603 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30604 int argc;
30605 PyObject *argv[3];
30606
30607 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30608 --argc;
30609 if (argc == 2) {
30610 int _v = 0;
30611 {
30612 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30613 _v = SWIG_CheckState(res);
30614 }
30615 if (!_v) goto check_1;
30616 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30617 }
30618 check_1:
30619
30620 if (argc == 2) {
30621 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30622 }
30623
30624 fail:
30625 Py_INCREF(Py_NotImplemented);
30626 return Py_NotImplemented;
30627 }
30628
30629
30630 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30631 PyObject *resultobj = 0;
30632 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30633 wxDataFormat *arg2 = 0 ;
30634 bool result;
30635 void *argp1 = 0 ;
30636 int res1 = 0 ;
30637 void *argp2 = 0 ;
30638 int res2 = 0 ;
30639
30640 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30642 if (!SWIG_IsOK(res1)) {
30643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30644 }
30645 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30646 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30647 if (!SWIG_IsOK(res2)) {
30648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30649 }
30650 if (!argp2) {
30651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30652 }
30653 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30654 {
30655 PyThreadState* __tstate = wxPyBeginAllowThreads();
30656 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30657 wxPyEndAllowThreads(__tstate);
30658 if (PyErr_Occurred()) SWIG_fail;
30659 }
30660 {
30661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30662 }
30663 return resultobj;
30664 fail:
30665 return NULL;
30666 }
30667
30668
30669 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30670 int argc;
30671 PyObject *argv[3];
30672
30673 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30674 --argc;
30675 if (argc == 2) {
30676 int _v = 0;
30677 {
30678 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30679 _v = SWIG_CheckState(res);
30680 }
30681 if (!_v) goto check_1;
30682 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30683 }
30684 check_1:
30685
30686 if (argc == 2) {
30687 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30688 }
30689
30690 fail:
30691 Py_INCREF(Py_NotImplemented);
30692 return Py_NotImplemented;
30693 }
30694
30695
30696 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30697 PyObject *resultobj = 0;
30698 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30699 wxDataFormatId arg2 ;
30700 void *argp1 = 0 ;
30701 int res1 = 0 ;
30702 int val2 ;
30703 int ecode2 = 0 ;
30704 PyObject * obj0 = 0 ;
30705 PyObject * obj1 = 0 ;
30706 char * kwnames[] = {
30707 (char *) "self",(char *) "format", NULL
30708 };
30709
30710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30712 if (!SWIG_IsOK(res1)) {
30713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30714 }
30715 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30716 ecode2 = SWIG_AsVal_int(obj1, &val2);
30717 if (!SWIG_IsOK(ecode2)) {
30718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30719 }
30720 arg2 = static_cast< wxDataFormatId >(val2);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 (arg1)->SetType(arg2);
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 resultobj = SWIG_Py_Void();
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30735 PyObject *resultobj = 0;
30736 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30737 wxDataFormatId result;
30738 void *argp1 = 0 ;
30739 int res1 = 0 ;
30740 PyObject *swig_obj[1] ;
30741
30742 if (!args) SWIG_fail;
30743 swig_obj[0] = args;
30744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30745 if (!SWIG_IsOK(res1)) {
30746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30747 }
30748 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30749 {
30750 PyThreadState* __tstate = wxPyBeginAllowThreads();
30751 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 resultobj = SWIG_From_int(static_cast< int >(result));
30756 return resultobj;
30757 fail:
30758 return NULL;
30759 }
30760
30761
30762 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30763 PyObject *resultobj = 0;
30764 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30765 wxString result;
30766 void *argp1 = 0 ;
30767 int res1 = 0 ;
30768 PyObject *swig_obj[1] ;
30769
30770 if (!args) SWIG_fail;
30771 swig_obj[0] = args;
30772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30773 if (!SWIG_IsOK(res1)) {
30774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30775 }
30776 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30777 {
30778 PyThreadState* __tstate = wxPyBeginAllowThreads();
30779 result = ((wxDataFormat const *)arg1)->GetId();
30780 wxPyEndAllowThreads(__tstate);
30781 if (PyErr_Occurred()) SWIG_fail;
30782 }
30783 {
30784 #if wxUSE_UNICODE
30785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30786 #else
30787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30788 #endif
30789 }
30790 return resultobj;
30791 fail:
30792 return NULL;
30793 }
30794
30795
30796 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30797 PyObject *resultobj = 0;
30798 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30799 wxString *arg2 = 0 ;
30800 void *argp1 = 0 ;
30801 int res1 = 0 ;
30802 bool temp2 = false ;
30803 PyObject * obj0 = 0 ;
30804 PyObject * obj1 = 0 ;
30805 char * kwnames[] = {
30806 (char *) "self",(char *) "format", NULL
30807 };
30808
30809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30813 }
30814 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30815 {
30816 arg2 = wxString_in_helper(obj1);
30817 if (arg2 == NULL) SWIG_fail;
30818 temp2 = true;
30819 }
30820 {
30821 PyThreadState* __tstate = wxPyBeginAllowThreads();
30822 (arg1)->SetId((wxString const &)*arg2);
30823 wxPyEndAllowThreads(__tstate);
30824 if (PyErr_Occurred()) SWIG_fail;
30825 }
30826 resultobj = SWIG_Py_Void();
30827 {
30828 if (temp2)
30829 delete arg2;
30830 }
30831 return resultobj;
30832 fail:
30833 {
30834 if (temp2)
30835 delete arg2;
30836 }
30837 return NULL;
30838 }
30839
30840
30841 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30842 PyObject *obj;
30843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30844 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30845 return SWIG_Py_Void();
30846 }
30847
30848 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30849 return SWIG_Python_InitShadowInstance(args);
30850 }
30851
30852 SWIGINTERN int FormatInvalid_set(PyObject *) {
30853 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30854 return 1;
30855 }
30856
30857
30858 SWIGINTERN PyObject *FormatInvalid_get(void) {
30859 PyObject *pyobj = 0;
30860
30861 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30862 return pyobj;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30867 PyObject *resultobj = 0;
30868 wxDataObject *arg1 = (wxDataObject *) 0 ;
30869 void *argp1 = 0 ;
30870 int res1 = 0 ;
30871 PyObject *swig_obj[1] ;
30872
30873 if (!args) SWIG_fail;
30874 swig_obj[0] = args;
30875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30876 if (!SWIG_IsOK(res1)) {
30877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30878 }
30879 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30880 {
30881 PyThreadState* __tstate = wxPyBeginAllowThreads();
30882 delete arg1;
30883
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 resultobj = SWIG_Py_Void();
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30895 PyObject *resultobj = 0;
30896 wxDataObject *arg1 = (wxDataObject *) 0 ;
30897 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30898 SwigValueWrapper<wxDataFormat > result;
30899 void *argp1 = 0 ;
30900 int res1 = 0 ;
30901 int val2 ;
30902 int ecode2 = 0 ;
30903 PyObject * obj0 = 0 ;
30904 PyObject * obj1 = 0 ;
30905 char * kwnames[] = {
30906 (char *) "self",(char *) "dir", NULL
30907 };
30908
30909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30911 if (!SWIG_IsOK(res1)) {
30912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30913 }
30914 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30915 if (obj1) {
30916 ecode2 = SWIG_AsVal_int(obj1, &val2);
30917 if (!SWIG_IsOK(ecode2)) {
30918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30919 }
30920 arg2 = static_cast< wxDataObject::Direction >(val2);
30921 }
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30929 return resultobj;
30930 fail:
30931 return NULL;
30932 }
30933
30934
30935 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30936 PyObject *resultobj = 0;
30937 wxDataObject *arg1 = (wxDataObject *) 0 ;
30938 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30939 size_t result;
30940 void *argp1 = 0 ;
30941 int res1 = 0 ;
30942 int val2 ;
30943 int ecode2 = 0 ;
30944 PyObject * obj0 = 0 ;
30945 PyObject * obj1 = 0 ;
30946 char * kwnames[] = {
30947 (char *) "self",(char *) "dir", NULL
30948 };
30949
30950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30954 }
30955 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30956 if (obj1) {
30957 ecode2 = SWIG_AsVal_int(obj1, &val2);
30958 if (!SWIG_IsOK(ecode2)) {
30959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30960 }
30961 arg2 = static_cast< wxDataObject::Direction >(val2);
30962 }
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30966 wxPyEndAllowThreads(__tstate);
30967 if (PyErr_Occurred()) SWIG_fail;
30968 }
30969 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30970 return resultobj;
30971 fail:
30972 return NULL;
30973 }
30974
30975
30976 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30977 PyObject *resultobj = 0;
30978 wxDataObject *arg1 = (wxDataObject *) 0 ;
30979 wxDataFormat *arg2 = 0 ;
30980 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30981 bool result;
30982 void *argp1 = 0 ;
30983 int res1 = 0 ;
30984 void *argp2 = 0 ;
30985 int res2 = 0 ;
30986 int val3 ;
30987 int ecode3 = 0 ;
30988 PyObject * obj0 = 0 ;
30989 PyObject * obj1 = 0 ;
30990 PyObject * obj2 = 0 ;
30991 char * kwnames[] = {
30992 (char *) "self",(char *) "format",(char *) "dir", NULL
30993 };
30994
30995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30999 }
31000 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31002 if (!SWIG_IsOK(res2)) {
31003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31004 }
31005 if (!argp2) {
31006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31007 }
31008 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31009 if (obj2) {
31010 ecode3 = SWIG_AsVal_int(obj2, &val3);
31011 if (!SWIG_IsOK(ecode3)) {
31012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31013 }
31014 arg3 = static_cast< wxDataObject::Direction >(val3);
31015 }
31016 {
31017 PyThreadState* __tstate = wxPyBeginAllowThreads();
31018 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31019 wxPyEndAllowThreads(__tstate);
31020 if (PyErr_Occurred()) SWIG_fail;
31021 }
31022 {
31023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31024 }
31025 return resultobj;
31026 fail:
31027 return NULL;
31028 }
31029
31030
31031 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31032 PyObject *resultobj = 0;
31033 wxDataObject *arg1 = (wxDataObject *) 0 ;
31034 wxDataFormat *arg2 = 0 ;
31035 size_t result;
31036 void *argp1 = 0 ;
31037 int res1 = 0 ;
31038 void *argp2 = 0 ;
31039 int res2 = 0 ;
31040 PyObject * obj0 = 0 ;
31041 PyObject * obj1 = 0 ;
31042 char * kwnames[] = {
31043 (char *) "self",(char *) "format", NULL
31044 };
31045
31046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31048 if (!SWIG_IsOK(res1)) {
31049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31050 }
31051 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31053 if (!SWIG_IsOK(res2)) {
31054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31055 }
31056 if (!argp2) {
31057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31058 }
31059 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31067 return resultobj;
31068 fail:
31069 return NULL;
31070 }
31071
31072
31073 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31074 PyObject *resultobj = 0;
31075 wxDataObject *arg1 = (wxDataObject *) 0 ;
31076 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31077 PyObject *result = 0 ;
31078 void *argp1 = 0 ;
31079 int res1 = 0 ;
31080 int val2 ;
31081 int ecode2 = 0 ;
31082 PyObject * obj0 = 0 ;
31083 PyObject * obj1 = 0 ;
31084 char * kwnames[] = {
31085 (char *) "self",(char *) "dir", NULL
31086 };
31087
31088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31090 if (!SWIG_IsOK(res1)) {
31091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31092 }
31093 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31094 if (obj1) {
31095 ecode2 = SWIG_AsVal_int(obj1, &val2);
31096 if (!SWIG_IsOK(ecode2)) {
31097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31098 }
31099 arg2 = static_cast< wxDataObject::Direction >(val2);
31100 }
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 resultobj = result;
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj = 0;
31116 wxDataObject *arg1 = (wxDataObject *) 0 ;
31117 wxDataFormat *arg2 = 0 ;
31118 PyObject *result = 0 ;
31119 void *argp1 = 0 ;
31120 int res1 = 0 ;
31121 void *argp2 = 0 ;
31122 int res2 = 0 ;
31123 PyObject * obj0 = 0 ;
31124 PyObject * obj1 = 0 ;
31125 char * kwnames[] = {
31126 (char *) "self",(char *) "format", NULL
31127 };
31128
31129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
31130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31131 if (!SWIG_IsOK(res1)) {
31132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
31133 }
31134 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31136 if (!SWIG_IsOK(res2)) {
31137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31138 }
31139 if (!argp2) {
31140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31141 }
31142 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = result;
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj = 0;
31158 wxDataObject *arg1 = (wxDataObject *) 0 ;
31159 wxDataFormat *arg2 = 0 ;
31160 PyObject *arg3 = (PyObject *) 0 ;
31161 bool result;
31162 void *argp1 = 0 ;
31163 int res1 = 0 ;
31164 void *argp2 = 0 ;
31165 int res2 = 0 ;
31166 PyObject * obj0 = 0 ;
31167 PyObject * obj1 = 0 ;
31168 PyObject * obj2 = 0 ;
31169 char * kwnames[] = {
31170 (char *) "self",(char *) "format",(char *) "data", NULL
31171 };
31172
31173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31175 if (!SWIG_IsOK(res1)) {
31176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
31177 }
31178 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31179 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31180 if (!SWIG_IsOK(res2)) {
31181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31182 }
31183 if (!argp2) {
31184 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31185 }
31186 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31187 arg3 = obj2;
31188 {
31189 PyThreadState* __tstate = wxPyBeginAllowThreads();
31190 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31191 wxPyEndAllowThreads(__tstate);
31192 if (PyErr_Occurred()) SWIG_fail;
31193 }
31194 {
31195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31196 }
31197 return resultobj;
31198 fail:
31199 return NULL;
31200 }
31201
31202
31203 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31204 PyObject *obj;
31205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31206 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31207 return SWIG_Py_Void();
31208 }
31209
31210 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31211 PyObject *resultobj = 0;
31212 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31213 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31214 wxDataObjectSimple *result = 0 ;
31215 void *argp1 = 0 ;
31216 int res1 = 0 ;
31217 PyObject * obj0 = 0 ;
31218 char * kwnames[] = {
31219 (char *) "format", NULL
31220 };
31221
31222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31223 if (obj0) {
31224 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31225 if (!SWIG_IsOK(res1)) {
31226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31227 }
31228 if (!argp1) {
31229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31230 }
31231 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31232 }
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31247 PyObject *resultobj = 0;
31248 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31249 wxDataFormat *result = 0 ;
31250 void *argp1 = 0 ;
31251 int res1 = 0 ;
31252 PyObject *swig_obj[1] ;
31253
31254 if (!args) SWIG_fail;
31255 swig_obj[0] = args;
31256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31257 if (!SWIG_IsOK(res1)) {
31258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31259 }
31260 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 {
31264 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31265 result = (wxDataFormat *) &_result_ref;
31266 }
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj = 0;
31279 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31280 wxDataFormat *arg2 = 0 ;
31281 void *argp1 = 0 ;
31282 int res1 = 0 ;
31283 void *argp2 = 0 ;
31284 int res2 = 0 ;
31285 PyObject * obj0 = 0 ;
31286 PyObject * obj1 = 0 ;
31287 char * kwnames[] = {
31288 (char *) "self",(char *) "format", NULL
31289 };
31290
31291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31293 if (!SWIG_IsOK(res1)) {
31294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31295 }
31296 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31297 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31298 if (!SWIG_IsOK(res2)) {
31299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31300 }
31301 if (!argp2) {
31302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31303 }
31304 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31305 {
31306 PyThreadState* __tstate = wxPyBeginAllowThreads();
31307 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 resultobj = SWIG_Py_Void();
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31319 PyObject *resultobj = 0;
31320 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31321 size_t result;
31322 void *argp1 = 0 ;
31323 int res1 = 0 ;
31324 PyObject *swig_obj[1] ;
31325
31326 if (!args) SWIG_fail;
31327 swig_obj[0] = args;
31328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31329 if (!SWIG_IsOK(res1)) {
31330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31331 }
31332 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31347 PyObject *resultobj = 0;
31348 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31349 PyObject *result = 0 ;
31350 void *argp1 = 0 ;
31351 int res1 = 0 ;
31352 PyObject *swig_obj[1] ;
31353
31354 if (!args) SWIG_fail;
31355 swig_obj[0] = args;
31356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31357 if (!SWIG_IsOK(res1)) {
31358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31359 }
31360 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31361 {
31362 PyThreadState* __tstate = wxPyBeginAllowThreads();
31363 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31364 wxPyEndAllowThreads(__tstate);
31365 if (PyErr_Occurred()) SWIG_fail;
31366 }
31367 resultobj = result;
31368 return resultobj;
31369 fail:
31370 return NULL;
31371 }
31372
31373
31374 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31375 PyObject *resultobj = 0;
31376 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31377 PyObject *arg2 = (PyObject *) 0 ;
31378 bool result;
31379 void *argp1 = 0 ;
31380 int res1 = 0 ;
31381 PyObject * obj0 = 0 ;
31382 PyObject * obj1 = 0 ;
31383 char * kwnames[] = {
31384 (char *) "self",(char *) "data", NULL
31385 };
31386
31387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31389 if (!SWIG_IsOK(res1)) {
31390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31391 }
31392 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31393 arg2 = obj1;
31394 {
31395 PyThreadState* __tstate = wxPyBeginAllowThreads();
31396 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31397 wxPyEndAllowThreads(__tstate);
31398 if (PyErr_Occurred()) SWIG_fail;
31399 }
31400 {
31401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31402 }
31403 return resultobj;
31404 fail:
31405 return NULL;
31406 }
31407
31408
31409 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31410 PyObject *obj;
31411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31412 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31413 return SWIG_Py_Void();
31414 }
31415
31416 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31417 return SWIG_Python_InitShadowInstance(args);
31418 }
31419
31420 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31421 PyObject *resultobj = 0;
31422 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31423 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31424 wxPyDataObjectSimple *result = 0 ;
31425 void *argp1 = 0 ;
31426 int res1 = 0 ;
31427 PyObject * obj0 = 0 ;
31428 char * kwnames[] = {
31429 (char *) "format", NULL
31430 };
31431
31432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31433 if (obj0) {
31434 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31435 if (!SWIG_IsOK(res1)) {
31436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31437 }
31438 if (!argp1) {
31439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31440 }
31441 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31442 }
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj = 0;
31458 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31459 PyObject *arg2 = (PyObject *) 0 ;
31460 PyObject *arg3 = (PyObject *) 0 ;
31461 void *argp1 = 0 ;
31462 int res1 = 0 ;
31463 PyObject * obj0 = 0 ;
31464 PyObject * obj1 = 0 ;
31465 PyObject * obj2 = 0 ;
31466 char * kwnames[] = {
31467 (char *) "self",(char *) "self",(char *) "_class", NULL
31468 };
31469
31470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31472 if (!SWIG_IsOK(res1)) {
31473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31474 }
31475 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31476 arg2 = obj1;
31477 arg3 = obj2;
31478 {
31479 PyThreadState* __tstate = wxPyBeginAllowThreads();
31480 (arg1)->_setCallbackInfo(arg2,arg3);
31481 wxPyEndAllowThreads(__tstate);
31482 if (PyErr_Occurred()) SWIG_fail;
31483 }
31484 resultobj = SWIG_Py_Void();
31485 return resultobj;
31486 fail:
31487 return NULL;
31488 }
31489
31490
31491 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31492 PyObject *obj;
31493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31494 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31495 return SWIG_Py_Void();
31496 }
31497
31498 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31499 return SWIG_Python_InitShadowInstance(args);
31500 }
31501
31502 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31503 PyObject *resultobj = 0;
31504 wxDataObjectComposite *result = 0 ;
31505
31506 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31514 return resultobj;
31515 fail:
31516 return NULL;
31517 }
31518
31519
31520 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31521 PyObject *resultobj = 0;
31522 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31523 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31524 bool arg3 = (bool) false ;
31525 void *argp1 = 0 ;
31526 int res1 = 0 ;
31527 int res2 = 0 ;
31528 bool val3 ;
31529 int ecode3 = 0 ;
31530 PyObject * obj0 = 0 ;
31531 PyObject * obj1 = 0 ;
31532 PyObject * obj2 = 0 ;
31533 char * kwnames[] = {
31534 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31535 };
31536
31537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31539 if (!SWIG_IsOK(res1)) {
31540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31541 }
31542 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31543 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31544 if (!SWIG_IsOK(res2)) {
31545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31546 }
31547 if (obj2) {
31548 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31549 if (!SWIG_IsOK(ecode3)) {
31550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31551 }
31552 arg3 = static_cast< bool >(val3);
31553 }
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 (arg1)->Add(arg2,arg3);
31557 wxPyEndAllowThreads(__tstate);
31558 if (PyErr_Occurred()) SWIG_fail;
31559 }
31560 resultobj = SWIG_Py_Void();
31561 return resultobj;
31562 fail:
31563 return NULL;
31564 }
31565
31566
31567 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31568 PyObject *resultobj = 0;
31569 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31570 SwigValueWrapper<wxDataFormat > result;
31571 void *argp1 = 0 ;
31572 int res1 = 0 ;
31573 PyObject *swig_obj[1] ;
31574
31575 if (!args) SWIG_fail;
31576 swig_obj[0] = args;
31577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31578 if (!SWIG_IsOK(res1)) {
31579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31580 }
31581 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31582 {
31583 PyThreadState* __tstate = wxPyBeginAllowThreads();
31584 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31585 wxPyEndAllowThreads(__tstate);
31586 if (PyErr_Occurred()) SWIG_fail;
31587 }
31588 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31589 return resultobj;
31590 fail:
31591 return NULL;
31592 }
31593
31594
31595 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31596 PyObject *obj;
31597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31598 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31599 return SWIG_Py_Void();
31600 }
31601
31602 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31603 return SWIG_Python_InitShadowInstance(args);
31604 }
31605
31606 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31607 PyObject *resultobj = 0;
31608 wxString const &arg1_defvalue = wxPyEmptyString ;
31609 wxString *arg1 = (wxString *) &arg1_defvalue ;
31610 wxTextDataObject *result = 0 ;
31611 bool temp1 = false ;
31612 PyObject * obj0 = 0 ;
31613 char * kwnames[] = {
31614 (char *) "text", NULL
31615 };
31616
31617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31618 if (obj0) {
31619 {
31620 arg1 = wxString_in_helper(obj0);
31621 if (arg1 == NULL) SWIG_fail;
31622 temp1 = true;
31623 }
31624 }
31625 {
31626 PyThreadState* __tstate = wxPyBeginAllowThreads();
31627 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31632 {
31633 if (temp1)
31634 delete arg1;
31635 }
31636 return resultobj;
31637 fail:
31638 {
31639 if (temp1)
31640 delete arg1;
31641 }
31642 return NULL;
31643 }
31644
31645
31646 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31647 PyObject *resultobj = 0;
31648 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31649 size_t result;
31650 void *argp1 = 0 ;
31651 int res1 = 0 ;
31652 PyObject *swig_obj[1] ;
31653
31654 if (!args) SWIG_fail;
31655 swig_obj[0] = args;
31656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31657 if (!SWIG_IsOK(res1)) {
31658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31659 }
31660 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31661 {
31662 PyThreadState* __tstate = wxPyBeginAllowThreads();
31663 result = (size_t)(arg1)->GetTextLength();
31664 wxPyEndAllowThreads(__tstate);
31665 if (PyErr_Occurred()) SWIG_fail;
31666 }
31667 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31668 return resultobj;
31669 fail:
31670 return NULL;
31671 }
31672
31673
31674 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31675 PyObject *resultobj = 0;
31676 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31677 wxString result;
31678 void *argp1 = 0 ;
31679 int res1 = 0 ;
31680 PyObject *swig_obj[1] ;
31681
31682 if (!args) SWIG_fail;
31683 swig_obj[0] = args;
31684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31685 if (!SWIG_IsOK(res1)) {
31686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31687 }
31688 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 result = (arg1)->GetText();
31692 wxPyEndAllowThreads(__tstate);
31693 if (PyErr_Occurred()) SWIG_fail;
31694 }
31695 {
31696 #if wxUSE_UNICODE
31697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31698 #else
31699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31700 #endif
31701 }
31702 return resultobj;
31703 fail:
31704 return NULL;
31705 }
31706
31707
31708 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31709 PyObject *resultobj = 0;
31710 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31711 wxString *arg2 = 0 ;
31712 void *argp1 = 0 ;
31713 int res1 = 0 ;
31714 bool temp2 = false ;
31715 PyObject * obj0 = 0 ;
31716 PyObject * obj1 = 0 ;
31717 char * kwnames[] = {
31718 (char *) "self",(char *) "text", NULL
31719 };
31720
31721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31723 if (!SWIG_IsOK(res1)) {
31724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31725 }
31726 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31727 {
31728 arg2 = wxString_in_helper(obj1);
31729 if (arg2 == NULL) SWIG_fail;
31730 temp2 = true;
31731 }
31732 {
31733 PyThreadState* __tstate = wxPyBeginAllowThreads();
31734 (arg1)->SetText((wxString const &)*arg2);
31735 wxPyEndAllowThreads(__tstate);
31736 if (PyErr_Occurred()) SWIG_fail;
31737 }
31738 resultobj = SWIG_Py_Void();
31739 {
31740 if (temp2)
31741 delete arg2;
31742 }
31743 return resultobj;
31744 fail:
31745 {
31746 if (temp2)
31747 delete arg2;
31748 }
31749 return NULL;
31750 }
31751
31752
31753 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31754 PyObject *obj;
31755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31756 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31757 return SWIG_Py_Void();
31758 }
31759
31760 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 return SWIG_Python_InitShadowInstance(args);
31762 }
31763
31764 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31765 PyObject *resultobj = 0;
31766 wxString const &arg1_defvalue = wxPyEmptyString ;
31767 wxString *arg1 = (wxString *) &arg1_defvalue ;
31768 wxPyTextDataObject *result = 0 ;
31769 bool temp1 = false ;
31770 PyObject * obj0 = 0 ;
31771 char * kwnames[] = {
31772 (char *) "text", NULL
31773 };
31774
31775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31776 if (obj0) {
31777 {
31778 arg1 = wxString_in_helper(obj0);
31779 if (arg1 == NULL) SWIG_fail;
31780 temp1 = true;
31781 }
31782 }
31783 {
31784 PyThreadState* __tstate = wxPyBeginAllowThreads();
31785 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31786 wxPyEndAllowThreads(__tstate);
31787 if (PyErr_Occurred()) SWIG_fail;
31788 }
31789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31790 {
31791 if (temp1)
31792 delete arg1;
31793 }
31794 return resultobj;
31795 fail:
31796 {
31797 if (temp1)
31798 delete arg1;
31799 }
31800 return NULL;
31801 }
31802
31803
31804 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31805 PyObject *resultobj = 0;
31806 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31807 PyObject *arg2 = (PyObject *) 0 ;
31808 PyObject *arg3 = (PyObject *) 0 ;
31809 void *argp1 = 0 ;
31810 int res1 = 0 ;
31811 PyObject * obj0 = 0 ;
31812 PyObject * obj1 = 0 ;
31813 PyObject * obj2 = 0 ;
31814 char * kwnames[] = {
31815 (char *) "self",(char *) "self",(char *) "_class", NULL
31816 };
31817
31818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31820 if (!SWIG_IsOK(res1)) {
31821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31822 }
31823 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31824 arg2 = obj1;
31825 arg3 = obj2;
31826 {
31827 PyThreadState* __tstate = wxPyBeginAllowThreads();
31828 (arg1)->_setCallbackInfo(arg2,arg3);
31829 wxPyEndAllowThreads(__tstate);
31830 if (PyErr_Occurred()) SWIG_fail;
31831 }
31832 resultobj = SWIG_Py_Void();
31833 return resultobj;
31834 fail:
31835 return NULL;
31836 }
31837
31838
31839 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31840 PyObject *obj;
31841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31842 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31843 return SWIG_Py_Void();
31844 }
31845
31846 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31847 return SWIG_Python_InitShadowInstance(args);
31848 }
31849
31850 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31851 PyObject *resultobj = 0;
31852 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31853 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31854 wxBitmapDataObject *result = 0 ;
31855 void *argp1 = 0 ;
31856 int res1 = 0 ;
31857 PyObject * obj0 = 0 ;
31858 char * kwnames[] = {
31859 (char *) "bitmap", NULL
31860 };
31861
31862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31863 if (obj0) {
31864 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31865 if (!SWIG_IsOK(res1)) {
31866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31867 }
31868 if (!argp1) {
31869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31870 }
31871 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31872 }
31873 {
31874 PyThreadState* __tstate = wxPyBeginAllowThreads();
31875 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31876 wxPyEndAllowThreads(__tstate);
31877 if (PyErr_Occurred()) SWIG_fail;
31878 }
31879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31880 return resultobj;
31881 fail:
31882 return NULL;
31883 }
31884
31885
31886 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31887 PyObject *resultobj = 0;
31888 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31889 wxBitmap result;
31890 void *argp1 = 0 ;
31891 int res1 = 0 ;
31892 PyObject *swig_obj[1] ;
31893
31894 if (!args) SWIG_fail;
31895 swig_obj[0] = args;
31896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31897 if (!SWIG_IsOK(res1)) {
31898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31899 }
31900 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31901 {
31902 PyThreadState* __tstate = wxPyBeginAllowThreads();
31903 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31904 wxPyEndAllowThreads(__tstate);
31905 if (PyErr_Occurred()) SWIG_fail;
31906 }
31907 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31908 return resultobj;
31909 fail:
31910 return NULL;
31911 }
31912
31913
31914 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31915 PyObject *resultobj = 0;
31916 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31917 wxBitmap *arg2 = 0 ;
31918 void *argp1 = 0 ;
31919 int res1 = 0 ;
31920 void *argp2 = 0 ;
31921 int res2 = 0 ;
31922 PyObject * obj0 = 0 ;
31923 PyObject * obj1 = 0 ;
31924 char * kwnames[] = {
31925 (char *) "self",(char *) "bitmap", NULL
31926 };
31927
31928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31930 if (!SWIG_IsOK(res1)) {
31931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31932 }
31933 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31935 if (!SWIG_IsOK(res2)) {
31936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31937 }
31938 if (!argp2) {
31939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31940 }
31941 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31942 {
31943 PyThreadState* __tstate = wxPyBeginAllowThreads();
31944 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 resultobj = SWIG_Py_Void();
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31956 PyObject *obj;
31957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31958 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31959 return SWIG_Py_Void();
31960 }
31961
31962 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31963 return SWIG_Python_InitShadowInstance(args);
31964 }
31965
31966 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31967 PyObject *resultobj = 0;
31968 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31969 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31970 wxPyBitmapDataObject *result = 0 ;
31971 void *argp1 = 0 ;
31972 int res1 = 0 ;
31973 PyObject * obj0 = 0 ;
31974 char * kwnames[] = {
31975 (char *) "bitmap", NULL
31976 };
31977
31978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31979 if (obj0) {
31980 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31981 if (!SWIG_IsOK(res1)) {
31982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31983 }
31984 if (!argp1) {
31985 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31986 }
31987 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31988 }
31989 {
31990 PyThreadState* __tstate = wxPyBeginAllowThreads();
31991 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31992 wxPyEndAllowThreads(__tstate);
31993 if (PyErr_Occurred()) SWIG_fail;
31994 }
31995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32003 PyObject *resultobj = 0;
32004 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
32005 PyObject *arg2 = (PyObject *) 0 ;
32006 PyObject *arg3 = (PyObject *) 0 ;
32007 void *argp1 = 0 ;
32008 int res1 = 0 ;
32009 PyObject * obj0 = 0 ;
32010 PyObject * obj1 = 0 ;
32011 PyObject * obj2 = 0 ;
32012 char * kwnames[] = {
32013 (char *) "self",(char *) "self",(char *) "_class", NULL
32014 };
32015
32016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32018 if (!SWIG_IsOK(res1)) {
32019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32020 }
32021 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32022 arg2 = obj1;
32023 arg3 = obj2;
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 (arg1)->_setCallbackInfo(arg2,arg3);
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 resultobj = SWIG_Py_Void();
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32038 PyObject *obj;
32039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32040 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32041 return SWIG_Py_Void();
32042 }
32043
32044 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32045 return SWIG_Python_InitShadowInstance(args);
32046 }
32047
32048 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32049 PyObject *resultobj = 0;
32050 wxFileDataObject *result = 0 ;
32051
32052 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
32053 {
32054 PyThreadState* __tstate = wxPyBeginAllowThreads();
32055 result = (wxFileDataObject *)new wxFileDataObject();
32056 wxPyEndAllowThreads(__tstate);
32057 if (PyErr_Occurred()) SWIG_fail;
32058 }
32059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32060 return resultobj;
32061 fail:
32062 return NULL;
32063 }
32064
32065
32066 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32067 PyObject *resultobj = 0;
32068 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32069 wxArrayString *result = 0 ;
32070 void *argp1 = 0 ;
32071 int res1 = 0 ;
32072 PyObject *swig_obj[1] ;
32073
32074 if (!args) SWIG_fail;
32075 swig_obj[0] = args;
32076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32077 if (!SWIG_IsOK(res1)) {
32078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32079 }
32080 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32081 {
32082 PyThreadState* __tstate = wxPyBeginAllowThreads();
32083 {
32084 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32085 result = (wxArrayString *) &_result_ref;
32086 }
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 {
32091 resultobj = wxArrayString2PyList_helper(*result);
32092 }
32093 return resultobj;
32094 fail:
32095 return NULL;
32096 }
32097
32098
32099 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32100 PyObject *resultobj = 0;
32101 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32102 wxString *arg2 = 0 ;
32103 void *argp1 = 0 ;
32104 int res1 = 0 ;
32105 bool temp2 = false ;
32106 PyObject * obj0 = 0 ;
32107 PyObject * obj1 = 0 ;
32108 char * kwnames[] = {
32109 (char *) "self",(char *) "filename", NULL
32110 };
32111
32112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
32113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32114 if (!SWIG_IsOK(res1)) {
32115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32116 }
32117 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32118 {
32119 arg2 = wxString_in_helper(obj1);
32120 if (arg2 == NULL) SWIG_fail;
32121 temp2 = true;
32122 }
32123 {
32124 PyThreadState* __tstate = wxPyBeginAllowThreads();
32125 (arg1)->AddFile((wxString const &)*arg2);
32126 wxPyEndAllowThreads(__tstate);
32127 if (PyErr_Occurred()) SWIG_fail;
32128 }
32129 resultobj = SWIG_Py_Void();
32130 {
32131 if (temp2)
32132 delete arg2;
32133 }
32134 return resultobj;
32135 fail:
32136 {
32137 if (temp2)
32138 delete arg2;
32139 }
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *obj;
32146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32147 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
32148 return SWIG_Py_Void();
32149 }
32150
32151 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32152 return SWIG_Python_InitShadowInstance(args);
32153 }
32154
32155 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32156 PyObject *resultobj = 0;
32157 wxDataFormat *arg1 = 0 ;
32158 wxCustomDataObject *result = 0 ;
32159 void *argp1 = 0 ;
32160 int res1 = 0 ;
32161
32162 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32164 if (!SWIG_IsOK(res1)) {
32165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32166 }
32167 if (!argp1) {
32168 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32169 }
32170 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32171 {
32172 PyThreadState* __tstate = wxPyBeginAllowThreads();
32173 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
32174 wxPyEndAllowThreads(__tstate);
32175 if (PyErr_Occurred()) SWIG_fail;
32176 }
32177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32178 return resultobj;
32179 fail:
32180 return NULL;
32181 }
32182
32183
32184 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32185 PyObject *resultobj = 0;
32186 wxString *arg1 = 0 ;
32187 wxCustomDataObject *result = 0 ;
32188 bool temp1 = false ;
32189
32190 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32191 {
32192 arg1 = wxString_in_helper(swig_obj[0]);
32193 if (arg1 == NULL) SWIG_fail;
32194 temp1 = true;
32195 }
32196 {
32197 PyThreadState* __tstate = wxPyBeginAllowThreads();
32198 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32199 wxPyEndAllowThreads(__tstate);
32200 if (PyErr_Occurred()) SWIG_fail;
32201 }
32202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32203 {
32204 if (temp1)
32205 delete arg1;
32206 }
32207 return resultobj;
32208 fail:
32209 {
32210 if (temp1)
32211 delete arg1;
32212 }
32213 return NULL;
32214 }
32215
32216
32217 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32218 PyObject *resultobj = 0;
32219 wxCustomDataObject *result = 0 ;
32220
32221 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = (wxCustomDataObject *)new wxCustomDataObject();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32236 int argc;
32237 PyObject *argv[2];
32238
32239 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32240 --argc;
32241 if (argc == 0) {
32242 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32243 }
32244 if (argc == 1) {
32245 int _v = 0;
32246 {
32247 {
32248 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32249 }
32250 }
32251 if (!_v) goto check_2;
32252 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32253 }
32254 check_2:
32255
32256 if (argc == 1) {
32257 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32258 }
32259
32260 fail:
32261 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32262 return NULL;
32263 }
32264
32265
32266 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32267 PyObject *resultobj = 0;
32268 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32269 PyObject *arg2 = (PyObject *) 0 ;
32270 bool result;
32271 void *argp1 = 0 ;
32272 int res1 = 0 ;
32273 PyObject * obj0 = 0 ;
32274 PyObject * obj1 = 0 ;
32275 char * kwnames[] = {
32276 (char *) "self",(char *) "data", NULL
32277 };
32278
32279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32281 if (!SWIG_IsOK(res1)) {
32282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32283 }
32284 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32285 arg2 = obj1;
32286 {
32287 PyThreadState* __tstate = wxPyBeginAllowThreads();
32288 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32289 wxPyEndAllowThreads(__tstate);
32290 if (PyErr_Occurred()) SWIG_fail;
32291 }
32292 {
32293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32294 }
32295 return resultobj;
32296 fail:
32297 return NULL;
32298 }
32299
32300
32301 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32302 PyObject *resultobj = 0;
32303 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32304 size_t result;
32305 void *argp1 = 0 ;
32306 int res1 = 0 ;
32307 PyObject *swig_obj[1] ;
32308
32309 if (!args) SWIG_fail;
32310 swig_obj[0] = args;
32311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32312 if (!SWIG_IsOK(res1)) {
32313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32314 }
32315 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32316 {
32317 PyThreadState* __tstate = wxPyBeginAllowThreads();
32318 result = (size_t)(arg1)->GetSize();
32319 wxPyEndAllowThreads(__tstate);
32320 if (PyErr_Occurred()) SWIG_fail;
32321 }
32322 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32330 PyObject *resultobj = 0;
32331 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32332 PyObject *result = 0 ;
32333 void *argp1 = 0 ;
32334 int res1 = 0 ;
32335 PyObject *swig_obj[1] ;
32336
32337 if (!args) SWIG_fail;
32338 swig_obj[0] = args;
32339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32340 if (!SWIG_IsOK(res1)) {
32341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32342 }
32343 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 resultobj = result;
32351 return resultobj;
32352 fail:
32353 return NULL;
32354 }
32355
32356
32357 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32358 PyObject *obj;
32359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32360 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32361 return SWIG_Py_Void();
32362 }
32363
32364 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32365 return SWIG_Python_InitShadowInstance(args);
32366 }
32367
32368 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32369 PyObject *resultobj = 0;
32370 wxURLDataObject *result = 0 ;
32371
32372 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 result = (wxURLDataObject *)new wxURLDataObject();
32376 wxPyEndAllowThreads(__tstate);
32377 if (PyErr_Occurred()) SWIG_fail;
32378 }
32379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32380 return resultobj;
32381 fail:
32382 return NULL;
32383 }
32384
32385
32386 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32387 PyObject *resultobj = 0;
32388 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32389 wxString result;
32390 void *argp1 = 0 ;
32391 int res1 = 0 ;
32392 PyObject *swig_obj[1] ;
32393
32394 if (!args) SWIG_fail;
32395 swig_obj[0] = args;
32396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32397 if (!SWIG_IsOK(res1)) {
32398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32399 }
32400 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32401 {
32402 PyThreadState* __tstate = wxPyBeginAllowThreads();
32403 result = (arg1)->GetURL();
32404 wxPyEndAllowThreads(__tstate);
32405 if (PyErr_Occurred()) SWIG_fail;
32406 }
32407 {
32408 #if wxUSE_UNICODE
32409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32410 #else
32411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32412 #endif
32413 }
32414 return resultobj;
32415 fail:
32416 return NULL;
32417 }
32418
32419
32420 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32421 PyObject *resultobj = 0;
32422 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32423 wxString *arg2 = 0 ;
32424 void *argp1 = 0 ;
32425 int res1 = 0 ;
32426 bool temp2 = false ;
32427 PyObject * obj0 = 0 ;
32428 PyObject * obj1 = 0 ;
32429 char * kwnames[] = {
32430 (char *) "self",(char *) "url", NULL
32431 };
32432
32433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32435 if (!SWIG_IsOK(res1)) {
32436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32437 }
32438 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32439 {
32440 arg2 = wxString_in_helper(obj1);
32441 if (arg2 == NULL) SWIG_fail;
32442 temp2 = true;
32443 }
32444 {
32445 PyThreadState* __tstate = wxPyBeginAllowThreads();
32446 (arg1)->SetURL((wxString const &)*arg2);
32447 wxPyEndAllowThreads(__tstate);
32448 if (PyErr_Occurred()) SWIG_fail;
32449 }
32450 resultobj = SWIG_Py_Void();
32451 {
32452 if (temp2)
32453 delete arg2;
32454 }
32455 return resultobj;
32456 fail:
32457 {
32458 if (temp2)
32459 delete arg2;
32460 }
32461 return NULL;
32462 }
32463
32464
32465 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32466 PyObject *obj;
32467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32468 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32469 return SWIG_Py_Void();
32470 }
32471
32472 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32473 return SWIG_Python_InitShadowInstance(args);
32474 }
32475
32476 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32477 PyObject *resultobj = 0;
32478 wxMetafileDataObject *result = 0 ;
32479
32480 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32481 {
32482 PyThreadState* __tstate = wxPyBeginAllowThreads();
32483 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32484 wxPyEndAllowThreads(__tstate);
32485 if (PyErr_Occurred()) SWIG_fail;
32486 }
32487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32488 return resultobj;
32489 fail:
32490 return NULL;
32491 }
32492
32493
32494 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32495 PyObject *obj;
32496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32497 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32498 return SWIG_Py_Void();
32499 }
32500
32501 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32502 return SWIG_Python_InitShadowInstance(args);
32503 }
32504
32505 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32506 PyObject *resultobj = 0;
32507 wxDragResult arg1 ;
32508 bool result;
32509 int val1 ;
32510 int ecode1 = 0 ;
32511 PyObject * obj0 = 0 ;
32512 char * kwnames[] = {
32513 (char *) "res", NULL
32514 };
32515
32516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32517 ecode1 = SWIG_AsVal_int(obj0, &val1);
32518 if (!SWIG_IsOK(ecode1)) {
32519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32520 }
32521 arg1 = static_cast< wxDragResult >(val1);
32522 {
32523 PyThreadState* __tstate = wxPyBeginAllowThreads();
32524 result = (bool)wxIsDragResultOk(arg1);
32525 wxPyEndAllowThreads(__tstate);
32526 if (PyErr_Occurred()) SWIG_fail;
32527 }
32528 {
32529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32530 }
32531 return resultobj;
32532 fail:
32533 return NULL;
32534 }
32535
32536
32537 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32538 PyObject *resultobj = 0;
32539 wxWindow *arg1 = (wxWindow *) 0 ;
32540 wxIcon const &arg2_defvalue = wxNullIcon ;
32541 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32542 wxIcon const &arg3_defvalue = wxNullIcon ;
32543 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32544 wxIcon const &arg4_defvalue = wxNullIcon ;
32545 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32546 wxPyDropSource *result = 0 ;
32547 void *argp1 = 0 ;
32548 int res1 = 0 ;
32549 void *argp2 = 0 ;
32550 int res2 = 0 ;
32551 void *argp3 = 0 ;
32552 int res3 = 0 ;
32553 void *argp4 = 0 ;
32554 int res4 = 0 ;
32555 PyObject * obj0 = 0 ;
32556 PyObject * obj1 = 0 ;
32557 PyObject * obj2 = 0 ;
32558 PyObject * obj3 = 0 ;
32559 char * kwnames[] = {
32560 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32561 };
32562
32563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32565 if (!SWIG_IsOK(res1)) {
32566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32567 }
32568 arg1 = reinterpret_cast< wxWindow * >(argp1);
32569 if (obj1) {
32570 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32571 if (!SWIG_IsOK(res2)) {
32572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32573 }
32574 if (!argp2) {
32575 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32576 }
32577 arg2 = reinterpret_cast< wxIcon * >(argp2);
32578 }
32579 if (obj2) {
32580 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32581 if (!SWIG_IsOK(res3)) {
32582 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32583 }
32584 if (!argp3) {
32585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32586 }
32587 arg3 = reinterpret_cast< wxIcon * >(argp3);
32588 }
32589 if (obj3) {
32590 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32591 if (!SWIG_IsOK(res4)) {
32592 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32593 }
32594 if (!argp4) {
32595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32596 }
32597 arg4 = reinterpret_cast< wxIcon * >(argp4);
32598 }
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32602 wxPyEndAllowThreads(__tstate);
32603 if (PyErr_Occurred()) SWIG_fail;
32604 }
32605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32606 return resultobj;
32607 fail:
32608 return NULL;
32609 }
32610
32611
32612 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32613 PyObject *resultobj = 0;
32614 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32615 PyObject *arg2 = (PyObject *) 0 ;
32616 PyObject *arg3 = (PyObject *) 0 ;
32617 int arg4 ;
32618 void *argp1 = 0 ;
32619 int res1 = 0 ;
32620 int val4 ;
32621 int ecode4 = 0 ;
32622 PyObject * obj0 = 0 ;
32623 PyObject * obj1 = 0 ;
32624 PyObject * obj2 = 0 ;
32625 PyObject * obj3 = 0 ;
32626 char * kwnames[] = {
32627 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32628 };
32629
32630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32632 if (!SWIG_IsOK(res1)) {
32633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32634 }
32635 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32636 arg2 = obj1;
32637 arg3 = obj2;
32638 ecode4 = SWIG_AsVal_int(obj3, &val4);
32639 if (!SWIG_IsOK(ecode4)) {
32640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32641 }
32642 arg4 = static_cast< int >(val4);
32643 {
32644 PyThreadState* __tstate = wxPyBeginAllowThreads();
32645 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32646 wxPyEndAllowThreads(__tstate);
32647 if (PyErr_Occurred()) SWIG_fail;
32648 }
32649 resultobj = SWIG_Py_Void();
32650 return resultobj;
32651 fail:
32652 return NULL;
32653 }
32654
32655
32656 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32657 PyObject *resultobj = 0;
32658 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32659 void *argp1 = 0 ;
32660 int res1 = 0 ;
32661 PyObject *swig_obj[1] ;
32662
32663 if (!args) SWIG_fail;
32664 swig_obj[0] = args;
32665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32666 if (!SWIG_IsOK(res1)) {
32667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32668 }
32669 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32670 {
32671 PyThreadState* __tstate = wxPyBeginAllowThreads();
32672 delete arg1;
32673
32674 wxPyEndAllowThreads(__tstate);
32675 if (PyErr_Occurred()) SWIG_fail;
32676 }
32677 resultobj = SWIG_Py_Void();
32678 return resultobj;
32679 fail:
32680 return NULL;
32681 }
32682
32683
32684 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32685 PyObject *resultobj = 0;
32686 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32687 wxDataObject *arg2 = 0 ;
32688 void *argp1 = 0 ;
32689 int res1 = 0 ;
32690 void *argp2 = 0 ;
32691 int res2 = 0 ;
32692 PyObject * obj0 = 0 ;
32693 PyObject * obj1 = 0 ;
32694 char * kwnames[] = {
32695 (char *) "self",(char *) "data", NULL
32696 };
32697
32698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32700 if (!SWIG_IsOK(res1)) {
32701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32702 }
32703 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32704 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32705 if (!SWIG_IsOK(res2)) {
32706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32707 }
32708 if (!argp2) {
32709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32710 }
32711 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32712 {
32713 PyThreadState* __tstate = wxPyBeginAllowThreads();
32714 (arg1)->SetData(*arg2);
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 resultobj = SWIG_Py_Void();
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32726 PyObject *resultobj = 0;
32727 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32728 wxDataObject *result = 0 ;
32729 void *argp1 = 0 ;
32730 int res1 = 0 ;
32731 PyObject *swig_obj[1] ;
32732
32733 if (!args) SWIG_fail;
32734 swig_obj[0] = args;
32735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32736 if (!SWIG_IsOK(res1)) {
32737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32738 }
32739 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32740 {
32741 PyThreadState* __tstate = wxPyBeginAllowThreads();
32742 result = (wxDataObject *)(arg1)->GetDataObject();
32743 wxPyEndAllowThreads(__tstate);
32744 if (PyErr_Occurred()) SWIG_fail;
32745 }
32746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32747 return resultobj;
32748 fail:
32749 return NULL;
32750 }
32751
32752
32753 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32754 PyObject *resultobj = 0;
32755 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32756 wxDragResult arg2 ;
32757 wxCursor *arg3 = 0 ;
32758 void *argp1 = 0 ;
32759 int res1 = 0 ;
32760 int val2 ;
32761 int ecode2 = 0 ;
32762 void *argp3 = 0 ;
32763 int res3 = 0 ;
32764 PyObject * obj0 = 0 ;
32765 PyObject * obj1 = 0 ;
32766 PyObject * obj2 = 0 ;
32767 char * kwnames[] = {
32768 (char *) "self",(char *) "res",(char *) "cursor", NULL
32769 };
32770
32771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32773 if (!SWIG_IsOK(res1)) {
32774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32775 }
32776 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32777 ecode2 = SWIG_AsVal_int(obj1, &val2);
32778 if (!SWIG_IsOK(ecode2)) {
32779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32780 }
32781 arg2 = static_cast< wxDragResult >(val2);
32782 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32783 if (!SWIG_IsOK(res3)) {
32784 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32785 }
32786 if (!argp3) {
32787 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32788 }
32789 arg3 = reinterpret_cast< wxCursor * >(argp3);
32790 {
32791 PyThreadState* __tstate = wxPyBeginAllowThreads();
32792 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32793 wxPyEndAllowThreads(__tstate);
32794 if (PyErr_Occurred()) SWIG_fail;
32795 }
32796 resultobj = SWIG_Py_Void();
32797 return resultobj;
32798 fail:
32799 return NULL;
32800 }
32801
32802
32803 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32804 PyObject *resultobj = 0;
32805 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32806 int arg2 = (int) wxDrag_CopyOnly ;
32807 wxDragResult result;
32808 void *argp1 = 0 ;
32809 int res1 = 0 ;
32810 int val2 ;
32811 int ecode2 = 0 ;
32812 PyObject * obj0 = 0 ;
32813 PyObject * obj1 = 0 ;
32814 char * kwnames[] = {
32815 (char *) "self",(char *) "flags", NULL
32816 };
32817
32818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32820 if (!SWIG_IsOK(res1)) {
32821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32822 }
32823 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32824 if (obj1) {
32825 ecode2 = SWIG_AsVal_int(obj1, &val2);
32826 if (!SWIG_IsOK(ecode2)) {
32827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32828 }
32829 arg2 = static_cast< int >(val2);
32830 }
32831 {
32832 PyThreadState* __tstate = wxPyBeginAllowThreads();
32833 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32834 wxPyEndAllowThreads(__tstate);
32835 if (PyErr_Occurred()) SWIG_fail;
32836 }
32837 resultobj = SWIG_From_int(static_cast< int >(result));
32838 return resultobj;
32839 fail:
32840 return NULL;
32841 }
32842
32843
32844 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32845 PyObject *resultobj = 0;
32846 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32847 wxDragResult arg2 ;
32848 bool result;
32849 void *argp1 = 0 ;
32850 int res1 = 0 ;
32851 int val2 ;
32852 int ecode2 = 0 ;
32853 PyObject * obj0 = 0 ;
32854 PyObject * obj1 = 0 ;
32855 char * kwnames[] = {
32856 (char *) "self",(char *) "effect", NULL
32857 };
32858
32859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32861 if (!SWIG_IsOK(res1)) {
32862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32863 }
32864 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32865 ecode2 = SWIG_AsVal_int(obj1, &val2);
32866 if (!SWIG_IsOK(ecode2)) {
32867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32868 }
32869 arg2 = static_cast< wxDragResult >(val2);
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (bool)(arg1)->GiveFeedback(arg2);
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 {
32877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32878 }
32879 return resultobj;
32880 fail:
32881 return NULL;
32882 }
32883
32884
32885 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32886 PyObject *obj;
32887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32888 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32889 return SWIG_Py_Void();
32890 }
32891
32892 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32893 return SWIG_Python_InitShadowInstance(args);
32894 }
32895
32896 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32897 PyObject *resultobj = 0;
32898 wxDataObject *arg1 = (wxDataObject *) NULL ;
32899 wxPyDropTarget *result = 0 ;
32900 int res1 = 0 ;
32901 PyObject * obj0 = 0 ;
32902 char * kwnames[] = {
32903 (char *) "dataObject", NULL
32904 };
32905
32906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32907 if (obj0) {
32908 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32909 if (!SWIG_IsOK(res1)) {
32910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32911 }
32912 }
32913 {
32914 PyThreadState* __tstate = wxPyBeginAllowThreads();
32915 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32916 wxPyEndAllowThreads(__tstate);
32917 if (PyErr_Occurred()) SWIG_fail;
32918 }
32919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32920 return resultobj;
32921 fail:
32922 return NULL;
32923 }
32924
32925
32926 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32927 PyObject *resultobj = 0;
32928 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32929 PyObject *arg2 = (PyObject *) 0 ;
32930 PyObject *arg3 = (PyObject *) 0 ;
32931 void *argp1 = 0 ;
32932 int res1 = 0 ;
32933 PyObject * obj0 = 0 ;
32934 PyObject * obj1 = 0 ;
32935 PyObject * obj2 = 0 ;
32936 char * kwnames[] = {
32937 (char *) "self",(char *) "self",(char *) "_class", NULL
32938 };
32939
32940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32942 if (!SWIG_IsOK(res1)) {
32943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32944 }
32945 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32946 arg2 = obj1;
32947 arg3 = obj2;
32948 {
32949 PyThreadState* __tstate = wxPyBeginAllowThreads();
32950 (arg1)->_setCallbackInfo(arg2,arg3);
32951 wxPyEndAllowThreads(__tstate);
32952 if (PyErr_Occurred()) SWIG_fail;
32953 }
32954 resultobj = SWIG_Py_Void();
32955 return resultobj;
32956 fail:
32957 return NULL;
32958 }
32959
32960
32961 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32962 PyObject *resultobj = 0;
32963 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32964 void *argp1 = 0 ;
32965 int res1 = 0 ;
32966 PyObject *swig_obj[1] ;
32967
32968 if (!args) SWIG_fail;
32969 swig_obj[0] = args;
32970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32971 if (!SWIG_IsOK(res1)) {
32972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32973 }
32974 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32975 {
32976 PyThreadState* __tstate = wxPyBeginAllowThreads();
32977 delete arg1;
32978
32979 wxPyEndAllowThreads(__tstate);
32980 if (PyErr_Occurred()) SWIG_fail;
32981 }
32982 resultobj = SWIG_Py_Void();
32983 return resultobj;
32984 fail:
32985 return NULL;
32986 }
32987
32988
32989 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32990 PyObject *resultobj = 0;
32991 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32992 wxDataObject *result = 0 ;
32993 void *argp1 = 0 ;
32994 int res1 = 0 ;
32995 PyObject *swig_obj[1] ;
32996
32997 if (!args) SWIG_fail;
32998 swig_obj[0] = args;
32999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33000 if (!SWIG_IsOK(res1)) {
33001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33002 }
33003 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33004 {
33005 PyThreadState* __tstate = wxPyBeginAllowThreads();
33006 result = (wxDataObject *)(arg1)->GetDataObject();
33007 wxPyEndAllowThreads(__tstate);
33008 if (PyErr_Occurred()) SWIG_fail;
33009 }
33010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33011 return resultobj;
33012 fail:
33013 return NULL;
33014 }
33015
33016
33017 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33018 PyObject *resultobj = 0;
33019 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33020 wxDataObject *arg2 = (wxDataObject *) 0 ;
33021 void *argp1 = 0 ;
33022 int res1 = 0 ;
33023 int res2 = 0 ;
33024 PyObject * obj0 = 0 ;
33025 PyObject * obj1 = 0 ;
33026 char * kwnames[] = {
33027 (char *) "self",(char *) "dataObject", NULL
33028 };
33029
33030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
33031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33032 if (!SWIG_IsOK(res1)) {
33033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33034 }
33035 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33036 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33037 if (!SWIG_IsOK(res2)) {
33038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
33039 }
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 (arg1)->SetDataObject(arg2);
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 resultobj = SWIG_Py_Void();
33047 return resultobj;
33048 fail:
33049 return NULL;
33050 }
33051
33052
33053 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33054 PyObject *resultobj = 0;
33055 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33056 int arg2 ;
33057 int arg3 ;
33058 wxDragResult arg4 ;
33059 wxDragResult result;
33060 void *argp1 = 0 ;
33061 int res1 = 0 ;
33062 int val2 ;
33063 int ecode2 = 0 ;
33064 int val3 ;
33065 int ecode3 = 0 ;
33066 int val4 ;
33067 int ecode4 = 0 ;
33068 PyObject * obj0 = 0 ;
33069 PyObject * obj1 = 0 ;
33070 PyObject * obj2 = 0 ;
33071 PyObject * obj3 = 0 ;
33072 char * kwnames[] = {
33073 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33074 };
33075
33076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33078 if (!SWIG_IsOK(res1)) {
33079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33080 }
33081 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33082 ecode2 = SWIG_AsVal_int(obj1, &val2);
33083 if (!SWIG_IsOK(ecode2)) {
33084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33085 }
33086 arg2 = static_cast< int >(val2);
33087 ecode3 = SWIG_AsVal_int(obj2, &val3);
33088 if (!SWIG_IsOK(ecode3)) {
33089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33090 }
33091 arg3 = static_cast< int >(val3);
33092 ecode4 = SWIG_AsVal_int(obj3, &val4);
33093 if (!SWIG_IsOK(ecode4)) {
33094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33095 }
33096 arg4 = static_cast< wxDragResult >(val4);
33097 {
33098 PyThreadState* __tstate = wxPyBeginAllowThreads();
33099 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33100 wxPyEndAllowThreads(__tstate);
33101 if (PyErr_Occurred()) SWIG_fail;
33102 }
33103 resultobj = SWIG_From_int(static_cast< int >(result));
33104 return resultobj;
33105 fail:
33106 return NULL;
33107 }
33108
33109
33110 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33111 PyObject *resultobj = 0;
33112 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33113 int arg2 ;
33114 int arg3 ;
33115 wxDragResult arg4 ;
33116 wxDragResult result;
33117 void *argp1 = 0 ;
33118 int res1 = 0 ;
33119 int val2 ;
33120 int ecode2 = 0 ;
33121 int val3 ;
33122 int ecode3 = 0 ;
33123 int val4 ;
33124 int ecode4 = 0 ;
33125 PyObject * obj0 = 0 ;
33126 PyObject * obj1 = 0 ;
33127 PyObject * obj2 = 0 ;
33128 PyObject * obj3 = 0 ;
33129 char * kwnames[] = {
33130 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33131 };
33132
33133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33135 if (!SWIG_IsOK(res1)) {
33136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33137 }
33138 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33139 ecode2 = SWIG_AsVal_int(obj1, &val2);
33140 if (!SWIG_IsOK(ecode2)) {
33141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33142 }
33143 arg2 = static_cast< int >(val2);
33144 ecode3 = SWIG_AsVal_int(obj2, &val3);
33145 if (!SWIG_IsOK(ecode3)) {
33146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33147 }
33148 arg3 = static_cast< int >(val3);
33149 ecode4 = SWIG_AsVal_int(obj3, &val4);
33150 if (!SWIG_IsOK(ecode4)) {
33151 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33152 }
33153 arg4 = static_cast< wxDragResult >(val4);
33154 {
33155 PyThreadState* __tstate = wxPyBeginAllowThreads();
33156 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33157 wxPyEndAllowThreads(__tstate);
33158 if (PyErr_Occurred()) SWIG_fail;
33159 }
33160 resultobj = SWIG_From_int(static_cast< int >(result));
33161 return resultobj;
33162 fail:
33163 return NULL;
33164 }
33165
33166
33167 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33168 PyObject *resultobj = 0;
33169 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33170 void *argp1 = 0 ;
33171 int res1 = 0 ;
33172 PyObject *swig_obj[1] ;
33173
33174 if (!args) SWIG_fail;
33175 swig_obj[0] = args;
33176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33177 if (!SWIG_IsOK(res1)) {
33178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33179 }
33180 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 (arg1)->OnLeave();
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 resultobj = SWIG_Py_Void();
33188 return resultobj;
33189 fail:
33190 return NULL;
33191 }
33192
33193
33194 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33195 PyObject *resultobj = 0;
33196 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33197 int arg2 ;
33198 int arg3 ;
33199 bool result;
33200 void *argp1 = 0 ;
33201 int res1 = 0 ;
33202 int val2 ;
33203 int ecode2 = 0 ;
33204 int val3 ;
33205 int ecode3 = 0 ;
33206 PyObject * obj0 = 0 ;
33207 PyObject * obj1 = 0 ;
33208 PyObject * obj2 = 0 ;
33209 char * kwnames[] = {
33210 (char *) "self",(char *) "x",(char *) "y", NULL
33211 };
33212
33213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33215 if (!SWIG_IsOK(res1)) {
33216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33217 }
33218 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33219 ecode2 = SWIG_AsVal_int(obj1, &val2);
33220 if (!SWIG_IsOK(ecode2)) {
33221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33222 }
33223 arg2 = static_cast< int >(val2);
33224 ecode3 = SWIG_AsVal_int(obj2, &val3);
33225 if (!SWIG_IsOK(ecode3)) {
33226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33227 }
33228 arg3 = static_cast< int >(val3);
33229 {
33230 PyThreadState* __tstate = wxPyBeginAllowThreads();
33231 result = (bool)(arg1)->OnDrop(arg2,arg3);
33232 wxPyEndAllowThreads(__tstate);
33233 if (PyErr_Occurred()) SWIG_fail;
33234 }
33235 {
33236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33237 }
33238 return resultobj;
33239 fail:
33240 return NULL;
33241 }
33242
33243
33244 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33245 PyObject *resultobj = 0;
33246 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33247 bool result;
33248 void *argp1 = 0 ;
33249 int res1 = 0 ;
33250 PyObject *swig_obj[1] ;
33251
33252 if (!args) SWIG_fail;
33253 swig_obj[0] = args;
33254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33255 if (!SWIG_IsOK(res1)) {
33256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33257 }
33258 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33259 {
33260 PyThreadState* __tstate = wxPyBeginAllowThreads();
33261 result = (bool)(arg1)->GetData();
33262 wxPyEndAllowThreads(__tstate);
33263 if (PyErr_Occurred()) SWIG_fail;
33264 }
33265 {
33266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33267 }
33268 return resultobj;
33269 fail:
33270 return NULL;
33271 }
33272
33273
33274 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33275 PyObject *resultobj = 0;
33276 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33277 wxDragResult arg2 ;
33278 void *argp1 = 0 ;
33279 int res1 = 0 ;
33280 int val2 ;
33281 int ecode2 = 0 ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 char * kwnames[] = {
33285 (char *) "self",(char *) "action", NULL
33286 };
33287
33288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33292 }
33293 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33294 ecode2 = SWIG_AsVal_int(obj1, &val2);
33295 if (!SWIG_IsOK(ecode2)) {
33296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33297 }
33298 arg2 = static_cast< wxDragResult >(val2);
33299 {
33300 PyThreadState* __tstate = wxPyBeginAllowThreads();
33301 (arg1)->SetDefaultAction(arg2);
33302 wxPyEndAllowThreads(__tstate);
33303 if (PyErr_Occurred()) SWIG_fail;
33304 }
33305 resultobj = SWIG_Py_Void();
33306 return resultobj;
33307 fail:
33308 return NULL;
33309 }
33310
33311
33312 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33313 PyObject *resultobj = 0;
33314 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33315 wxDragResult result;
33316 void *argp1 = 0 ;
33317 int res1 = 0 ;
33318 PyObject *swig_obj[1] ;
33319
33320 if (!args) SWIG_fail;
33321 swig_obj[0] = args;
33322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33323 if (!SWIG_IsOK(res1)) {
33324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33325 }
33326 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 result = (wxDragResult)(arg1)->GetDefaultAction();
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 resultobj = SWIG_From_int(static_cast< int >(result));
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33341 PyObject *obj;
33342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33343 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33344 return SWIG_Py_Void();
33345 }
33346
33347 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33348 return SWIG_Python_InitShadowInstance(args);
33349 }
33350
33351 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33352 PyObject *resultobj = 0;
33353 wxPyTextDropTarget *result = 0 ;
33354
33355 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33356 {
33357 PyThreadState* __tstate = wxPyBeginAllowThreads();
33358 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33359 wxPyEndAllowThreads(__tstate);
33360 if (PyErr_Occurred()) SWIG_fail;
33361 }
33362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33370 PyObject *resultobj = 0;
33371 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33372 PyObject *arg2 = (PyObject *) 0 ;
33373 PyObject *arg3 = (PyObject *) 0 ;
33374 void *argp1 = 0 ;
33375 int res1 = 0 ;
33376 PyObject * obj0 = 0 ;
33377 PyObject * obj1 = 0 ;
33378 PyObject * obj2 = 0 ;
33379 char * kwnames[] = {
33380 (char *) "self",(char *) "self",(char *) "_class", NULL
33381 };
33382
33383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33385 if (!SWIG_IsOK(res1)) {
33386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33387 }
33388 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33389 arg2 = obj1;
33390 arg3 = obj2;
33391 {
33392 PyThreadState* __tstate = wxPyBeginAllowThreads();
33393 (arg1)->_setCallbackInfo(arg2,arg3);
33394 wxPyEndAllowThreads(__tstate);
33395 if (PyErr_Occurred()) SWIG_fail;
33396 }
33397 resultobj = SWIG_Py_Void();
33398 return resultobj;
33399 fail:
33400 return NULL;
33401 }
33402
33403
33404 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33405 PyObject *resultobj = 0;
33406 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33407 int arg2 ;
33408 int arg3 ;
33409 wxString *arg4 = 0 ;
33410 bool result;
33411 void *argp1 = 0 ;
33412 int res1 = 0 ;
33413 int val2 ;
33414 int ecode2 = 0 ;
33415 int val3 ;
33416 int ecode3 = 0 ;
33417 bool temp4 = false ;
33418 PyObject * obj0 = 0 ;
33419 PyObject * obj1 = 0 ;
33420 PyObject * obj2 = 0 ;
33421 PyObject * obj3 = 0 ;
33422 char * kwnames[] = {
33423 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33424 };
33425
33426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33428 if (!SWIG_IsOK(res1)) {
33429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33430 }
33431 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33432 ecode2 = SWIG_AsVal_int(obj1, &val2);
33433 if (!SWIG_IsOK(ecode2)) {
33434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33435 }
33436 arg2 = static_cast< int >(val2);
33437 ecode3 = SWIG_AsVal_int(obj2, &val3);
33438 if (!SWIG_IsOK(ecode3)) {
33439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33440 }
33441 arg3 = static_cast< int >(val3);
33442 {
33443 arg4 = wxString_in_helper(obj3);
33444 if (arg4 == NULL) SWIG_fail;
33445 temp4 = true;
33446 }
33447 {
33448 PyThreadState* __tstate = wxPyBeginAllowThreads();
33449 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33450 wxPyEndAllowThreads(__tstate);
33451 if (PyErr_Occurred()) SWIG_fail;
33452 }
33453 {
33454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33455 }
33456 {
33457 if (temp4)
33458 delete arg4;
33459 }
33460 return resultobj;
33461 fail:
33462 {
33463 if (temp4)
33464 delete arg4;
33465 }
33466 return NULL;
33467 }
33468
33469
33470 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33471 PyObject *resultobj = 0;
33472 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33473 int arg2 ;
33474 int arg3 ;
33475 wxDragResult arg4 ;
33476 wxDragResult result;
33477 void *argp1 = 0 ;
33478 int res1 = 0 ;
33479 int val2 ;
33480 int ecode2 = 0 ;
33481 int val3 ;
33482 int ecode3 = 0 ;
33483 int val4 ;
33484 int ecode4 = 0 ;
33485 PyObject * obj0 = 0 ;
33486 PyObject * obj1 = 0 ;
33487 PyObject * obj2 = 0 ;
33488 PyObject * obj3 = 0 ;
33489 char * kwnames[] = {
33490 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33491 };
33492
33493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33495 if (!SWIG_IsOK(res1)) {
33496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33497 }
33498 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33499 ecode2 = SWIG_AsVal_int(obj1, &val2);
33500 if (!SWIG_IsOK(ecode2)) {
33501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33502 }
33503 arg2 = static_cast< int >(val2);
33504 ecode3 = SWIG_AsVal_int(obj2, &val3);
33505 if (!SWIG_IsOK(ecode3)) {
33506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33507 }
33508 arg3 = static_cast< int >(val3);
33509 ecode4 = SWIG_AsVal_int(obj3, &val4);
33510 if (!SWIG_IsOK(ecode4)) {
33511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33512 }
33513 arg4 = static_cast< wxDragResult >(val4);
33514 {
33515 PyThreadState* __tstate = wxPyBeginAllowThreads();
33516 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33517 wxPyEndAllowThreads(__tstate);
33518 if (PyErr_Occurred()) SWIG_fail;
33519 }
33520 resultobj = SWIG_From_int(static_cast< int >(result));
33521 return resultobj;
33522 fail:
33523 return NULL;
33524 }
33525
33526
33527 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33528 PyObject *resultobj = 0;
33529 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33530 int arg2 ;
33531 int arg3 ;
33532 wxDragResult arg4 ;
33533 wxDragResult result;
33534 void *argp1 = 0 ;
33535 int res1 = 0 ;
33536 int val2 ;
33537 int ecode2 = 0 ;
33538 int val3 ;
33539 int ecode3 = 0 ;
33540 int val4 ;
33541 int ecode4 = 0 ;
33542 PyObject * obj0 = 0 ;
33543 PyObject * obj1 = 0 ;
33544 PyObject * obj2 = 0 ;
33545 PyObject * obj3 = 0 ;
33546 char * kwnames[] = {
33547 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33548 };
33549
33550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33552 if (!SWIG_IsOK(res1)) {
33553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33554 }
33555 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33556 ecode2 = SWIG_AsVal_int(obj1, &val2);
33557 if (!SWIG_IsOK(ecode2)) {
33558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33559 }
33560 arg2 = static_cast< int >(val2);
33561 ecode3 = SWIG_AsVal_int(obj2, &val3);
33562 if (!SWIG_IsOK(ecode3)) {
33563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33564 }
33565 arg3 = static_cast< int >(val3);
33566 ecode4 = SWIG_AsVal_int(obj3, &val4);
33567 if (!SWIG_IsOK(ecode4)) {
33568 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33569 }
33570 arg4 = static_cast< wxDragResult >(val4);
33571 {
33572 PyThreadState* __tstate = wxPyBeginAllowThreads();
33573 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33574 wxPyEndAllowThreads(__tstate);
33575 if (PyErr_Occurred()) SWIG_fail;
33576 }
33577 resultobj = SWIG_From_int(static_cast< int >(result));
33578 return resultobj;
33579 fail:
33580 return NULL;
33581 }
33582
33583
33584 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33585 PyObject *resultobj = 0;
33586 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33587 void *argp1 = 0 ;
33588 int res1 = 0 ;
33589 PyObject *swig_obj[1] ;
33590
33591 if (!args) SWIG_fail;
33592 swig_obj[0] = args;
33593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33594 if (!SWIG_IsOK(res1)) {
33595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33596 }
33597 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33598 {
33599 PyThreadState* __tstate = wxPyBeginAllowThreads();
33600 (arg1)->OnLeave();
33601 wxPyEndAllowThreads(__tstate);
33602 if (PyErr_Occurred()) SWIG_fail;
33603 }
33604 resultobj = SWIG_Py_Void();
33605 return resultobj;
33606 fail:
33607 return NULL;
33608 }
33609
33610
33611 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33612 PyObject *resultobj = 0;
33613 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33614 int arg2 ;
33615 int arg3 ;
33616 bool result;
33617 void *argp1 = 0 ;
33618 int res1 = 0 ;
33619 int val2 ;
33620 int ecode2 = 0 ;
33621 int val3 ;
33622 int ecode3 = 0 ;
33623 PyObject * obj0 = 0 ;
33624 PyObject * obj1 = 0 ;
33625 PyObject * obj2 = 0 ;
33626 char * kwnames[] = {
33627 (char *) "self",(char *) "x",(char *) "y", NULL
33628 };
33629
33630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33632 if (!SWIG_IsOK(res1)) {
33633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33634 }
33635 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33636 ecode2 = SWIG_AsVal_int(obj1, &val2);
33637 if (!SWIG_IsOK(ecode2)) {
33638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33639 }
33640 arg2 = static_cast< int >(val2);
33641 ecode3 = SWIG_AsVal_int(obj2, &val3);
33642 if (!SWIG_IsOK(ecode3)) {
33643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33644 }
33645 arg3 = static_cast< int >(val3);
33646 {
33647 PyThreadState* __tstate = wxPyBeginAllowThreads();
33648 result = (bool)(arg1)->OnDrop(arg2,arg3);
33649 wxPyEndAllowThreads(__tstate);
33650 if (PyErr_Occurred()) SWIG_fail;
33651 }
33652 {
33653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33654 }
33655 return resultobj;
33656 fail:
33657 return NULL;
33658 }
33659
33660
33661 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33662 PyObject *resultobj = 0;
33663 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33664 int arg2 ;
33665 int arg3 ;
33666 wxDragResult arg4 ;
33667 wxDragResult result;
33668 void *argp1 = 0 ;
33669 int res1 = 0 ;
33670 int val2 ;
33671 int ecode2 = 0 ;
33672 int val3 ;
33673 int ecode3 = 0 ;
33674 int val4 ;
33675 int ecode4 = 0 ;
33676 PyObject * obj0 = 0 ;
33677 PyObject * obj1 = 0 ;
33678 PyObject * obj2 = 0 ;
33679 PyObject * obj3 = 0 ;
33680 char * kwnames[] = {
33681 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33682 };
33683
33684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33686 if (!SWIG_IsOK(res1)) {
33687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33688 }
33689 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33690 ecode2 = SWIG_AsVal_int(obj1, &val2);
33691 if (!SWIG_IsOK(ecode2)) {
33692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33693 }
33694 arg2 = static_cast< int >(val2);
33695 ecode3 = SWIG_AsVal_int(obj2, &val3);
33696 if (!SWIG_IsOK(ecode3)) {
33697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33698 }
33699 arg3 = static_cast< int >(val3);
33700 ecode4 = SWIG_AsVal_int(obj3, &val4);
33701 if (!SWIG_IsOK(ecode4)) {
33702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33703 }
33704 arg4 = static_cast< wxDragResult >(val4);
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33708 wxPyEndAllowThreads(__tstate);
33709 if (PyErr_Occurred()) SWIG_fail;
33710 }
33711 resultobj = SWIG_From_int(static_cast< int >(result));
33712 return resultobj;
33713 fail:
33714 return NULL;
33715 }
33716
33717
33718 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33719 PyObject *obj;
33720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33721 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33722 return SWIG_Py_Void();
33723 }
33724
33725 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33726 return SWIG_Python_InitShadowInstance(args);
33727 }
33728
33729 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33730 PyObject *resultobj = 0;
33731 wxPyFileDropTarget *result = 0 ;
33732
33733 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33734 {
33735 PyThreadState* __tstate = wxPyBeginAllowThreads();
33736 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33737 wxPyEndAllowThreads(__tstate);
33738 if (PyErr_Occurred()) SWIG_fail;
33739 }
33740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33741 return resultobj;
33742 fail:
33743 return NULL;
33744 }
33745
33746
33747 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33748 PyObject *resultobj = 0;
33749 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33750 PyObject *arg2 = (PyObject *) 0 ;
33751 PyObject *arg3 = (PyObject *) 0 ;
33752 void *argp1 = 0 ;
33753 int res1 = 0 ;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 PyObject * obj2 = 0 ;
33757 char * kwnames[] = {
33758 (char *) "self",(char *) "self",(char *) "_class", NULL
33759 };
33760
33761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33763 if (!SWIG_IsOK(res1)) {
33764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33765 }
33766 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33767 arg2 = obj1;
33768 arg3 = obj2;
33769 {
33770 PyThreadState* __tstate = wxPyBeginAllowThreads();
33771 (arg1)->_setCallbackInfo(arg2,arg3);
33772 wxPyEndAllowThreads(__tstate);
33773 if (PyErr_Occurred()) SWIG_fail;
33774 }
33775 resultobj = SWIG_Py_Void();
33776 return resultobj;
33777 fail:
33778 return NULL;
33779 }
33780
33781
33782 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33783 PyObject *resultobj = 0;
33784 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33785 int arg2 ;
33786 int arg3 ;
33787 wxArrayString *arg4 = 0 ;
33788 bool result;
33789 void *argp1 = 0 ;
33790 int res1 = 0 ;
33791 int val2 ;
33792 int ecode2 = 0 ;
33793 int val3 ;
33794 int ecode3 = 0 ;
33795 bool temp4 = false ;
33796 PyObject * obj0 = 0 ;
33797 PyObject * obj1 = 0 ;
33798 PyObject * obj2 = 0 ;
33799 PyObject * obj3 = 0 ;
33800 char * kwnames[] = {
33801 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33802 };
33803
33804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33806 if (!SWIG_IsOK(res1)) {
33807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33808 }
33809 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33810 ecode2 = SWIG_AsVal_int(obj1, &val2);
33811 if (!SWIG_IsOK(ecode2)) {
33812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33813 }
33814 arg2 = static_cast< int >(val2);
33815 ecode3 = SWIG_AsVal_int(obj2, &val3);
33816 if (!SWIG_IsOK(ecode3)) {
33817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33818 }
33819 arg3 = static_cast< int >(val3);
33820 {
33821 if (! PySequence_Check(obj3)) {
33822 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33823 SWIG_fail;
33824 }
33825 arg4 = new wxArrayString;
33826 temp4 = true;
33827 int i, len=PySequence_Length(obj3);
33828 for (i=0; i<len; i++) {
33829 PyObject* item = PySequence_GetItem(obj3, i);
33830 wxString* s = wxString_in_helper(item);
33831 if (PyErr_Occurred()) SWIG_fail;
33832 arg4->Add(*s);
33833 delete s;
33834 Py_DECREF(item);
33835 }
33836 }
33837 {
33838 PyThreadState* __tstate = wxPyBeginAllowThreads();
33839 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33840 wxPyEndAllowThreads(__tstate);
33841 if (PyErr_Occurred()) SWIG_fail;
33842 }
33843 {
33844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33845 }
33846 {
33847 if (temp4) delete arg4;
33848 }
33849 return resultobj;
33850 fail:
33851 {
33852 if (temp4) delete arg4;
33853 }
33854 return NULL;
33855 }
33856
33857
33858 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33859 PyObject *resultobj = 0;
33860 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33861 int arg2 ;
33862 int arg3 ;
33863 wxDragResult arg4 ;
33864 wxDragResult result;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 int val2 ;
33868 int ecode2 = 0 ;
33869 int val3 ;
33870 int ecode3 = 0 ;
33871 int val4 ;
33872 int ecode4 = 0 ;
33873 PyObject * obj0 = 0 ;
33874 PyObject * obj1 = 0 ;
33875 PyObject * obj2 = 0 ;
33876 PyObject * obj3 = 0 ;
33877 char * kwnames[] = {
33878 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33879 };
33880
33881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33883 if (!SWIG_IsOK(res1)) {
33884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33885 }
33886 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33887 ecode2 = SWIG_AsVal_int(obj1, &val2);
33888 if (!SWIG_IsOK(ecode2)) {
33889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33890 }
33891 arg2 = static_cast< int >(val2);
33892 ecode3 = SWIG_AsVal_int(obj2, &val3);
33893 if (!SWIG_IsOK(ecode3)) {
33894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33895 }
33896 arg3 = static_cast< int >(val3);
33897 ecode4 = SWIG_AsVal_int(obj3, &val4);
33898 if (!SWIG_IsOK(ecode4)) {
33899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33900 }
33901 arg4 = static_cast< wxDragResult >(val4);
33902 {
33903 PyThreadState* __tstate = wxPyBeginAllowThreads();
33904 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33905 wxPyEndAllowThreads(__tstate);
33906 if (PyErr_Occurred()) SWIG_fail;
33907 }
33908 resultobj = SWIG_From_int(static_cast< int >(result));
33909 return resultobj;
33910 fail:
33911 return NULL;
33912 }
33913
33914
33915 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33916 PyObject *resultobj = 0;
33917 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33918 int arg2 ;
33919 int arg3 ;
33920 wxDragResult arg4 ;
33921 wxDragResult result;
33922 void *argp1 = 0 ;
33923 int res1 = 0 ;
33924 int val2 ;
33925 int ecode2 = 0 ;
33926 int val3 ;
33927 int ecode3 = 0 ;
33928 int val4 ;
33929 int ecode4 = 0 ;
33930 PyObject * obj0 = 0 ;
33931 PyObject * obj1 = 0 ;
33932 PyObject * obj2 = 0 ;
33933 PyObject * obj3 = 0 ;
33934 char * kwnames[] = {
33935 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33936 };
33937
33938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33940 if (!SWIG_IsOK(res1)) {
33941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33942 }
33943 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33944 ecode2 = SWIG_AsVal_int(obj1, &val2);
33945 if (!SWIG_IsOK(ecode2)) {
33946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33947 }
33948 arg2 = static_cast< int >(val2);
33949 ecode3 = SWIG_AsVal_int(obj2, &val3);
33950 if (!SWIG_IsOK(ecode3)) {
33951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33952 }
33953 arg3 = static_cast< int >(val3);
33954 ecode4 = SWIG_AsVal_int(obj3, &val4);
33955 if (!SWIG_IsOK(ecode4)) {
33956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33957 }
33958 arg4 = static_cast< wxDragResult >(val4);
33959 {
33960 PyThreadState* __tstate = wxPyBeginAllowThreads();
33961 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33962 wxPyEndAllowThreads(__tstate);
33963 if (PyErr_Occurred()) SWIG_fail;
33964 }
33965 resultobj = SWIG_From_int(static_cast< int >(result));
33966 return resultobj;
33967 fail:
33968 return NULL;
33969 }
33970
33971
33972 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33973 PyObject *resultobj = 0;
33974 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33975 void *argp1 = 0 ;
33976 int res1 = 0 ;
33977 PyObject *swig_obj[1] ;
33978
33979 if (!args) SWIG_fail;
33980 swig_obj[0] = args;
33981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33984 }
33985 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33986 {
33987 PyThreadState* __tstate = wxPyBeginAllowThreads();
33988 (arg1)->OnLeave();
33989 wxPyEndAllowThreads(__tstate);
33990 if (PyErr_Occurred()) SWIG_fail;
33991 }
33992 resultobj = SWIG_Py_Void();
33993 return resultobj;
33994 fail:
33995 return NULL;
33996 }
33997
33998
33999 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34000 PyObject *resultobj = 0;
34001 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34002 int arg2 ;
34003 int arg3 ;
34004 bool result;
34005 void *argp1 = 0 ;
34006 int res1 = 0 ;
34007 int val2 ;
34008 int ecode2 = 0 ;
34009 int val3 ;
34010 int ecode3 = 0 ;
34011 PyObject * obj0 = 0 ;
34012 PyObject * obj1 = 0 ;
34013 PyObject * obj2 = 0 ;
34014 char * kwnames[] = {
34015 (char *) "self",(char *) "x",(char *) "y", NULL
34016 };
34017
34018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34020 if (!SWIG_IsOK(res1)) {
34021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34022 }
34023 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34024 ecode2 = SWIG_AsVal_int(obj1, &val2);
34025 if (!SWIG_IsOK(ecode2)) {
34026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34027 }
34028 arg2 = static_cast< int >(val2);
34029 ecode3 = SWIG_AsVal_int(obj2, &val3);
34030 if (!SWIG_IsOK(ecode3)) {
34031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34032 }
34033 arg3 = static_cast< int >(val3);
34034 {
34035 PyThreadState* __tstate = wxPyBeginAllowThreads();
34036 result = (bool)(arg1)->OnDrop(arg2,arg3);
34037 wxPyEndAllowThreads(__tstate);
34038 if (PyErr_Occurred()) SWIG_fail;
34039 }
34040 {
34041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34042 }
34043 return resultobj;
34044 fail:
34045 return NULL;
34046 }
34047
34048
34049 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34050 PyObject *resultobj = 0;
34051 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34052 int arg2 ;
34053 int arg3 ;
34054 wxDragResult arg4 ;
34055 wxDragResult result;
34056 void *argp1 = 0 ;
34057 int res1 = 0 ;
34058 int val2 ;
34059 int ecode2 = 0 ;
34060 int val3 ;
34061 int ecode3 = 0 ;
34062 int val4 ;
34063 int ecode4 = 0 ;
34064 PyObject * obj0 = 0 ;
34065 PyObject * obj1 = 0 ;
34066 PyObject * obj2 = 0 ;
34067 PyObject * obj3 = 0 ;
34068 char * kwnames[] = {
34069 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34070 };
34071
34072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34074 if (!SWIG_IsOK(res1)) {
34075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34076 }
34077 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34078 ecode2 = SWIG_AsVal_int(obj1, &val2);
34079 if (!SWIG_IsOK(ecode2)) {
34080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34081 }
34082 arg2 = static_cast< int >(val2);
34083 ecode3 = SWIG_AsVal_int(obj2, &val3);
34084 if (!SWIG_IsOK(ecode3)) {
34085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34086 }
34087 arg3 = static_cast< int >(val3);
34088 ecode4 = SWIG_AsVal_int(obj3, &val4);
34089 if (!SWIG_IsOK(ecode4)) {
34090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34091 }
34092 arg4 = static_cast< wxDragResult >(val4);
34093 {
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 resultobj = SWIG_From_int(static_cast< int >(result));
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34107 PyObject *obj;
34108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34109 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
34110 return SWIG_Py_Void();
34111 }
34112
34113 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34114 return SWIG_Python_InitShadowInstance(args);
34115 }
34116
34117 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34118 PyObject *resultobj = 0;
34119 wxClipboard *result = 0 ;
34120
34121 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34122 {
34123 PyThreadState* __tstate = wxPyBeginAllowThreads();
34124 result = (wxClipboard *)new wxClipboard();
34125 wxPyEndAllowThreads(__tstate);
34126 if (PyErr_Occurred()) SWIG_fail;
34127 }
34128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34129 return resultobj;
34130 fail:
34131 return NULL;
34132 }
34133
34134
34135 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34136 PyObject *resultobj = 0;
34137 wxClipboard *arg1 = (wxClipboard *) 0 ;
34138 void *argp1 = 0 ;
34139 int res1 = 0 ;
34140 PyObject *swig_obj[1] ;
34141
34142 if (!args) SWIG_fail;
34143 swig_obj[0] = args;
34144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34145 if (!SWIG_IsOK(res1)) {
34146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34147 }
34148 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34149 {
34150 PyThreadState* __tstate = wxPyBeginAllowThreads();
34151 delete arg1;
34152
34153 wxPyEndAllowThreads(__tstate);
34154 if (PyErr_Occurred()) SWIG_fail;
34155 }
34156 resultobj = SWIG_Py_Void();
34157 return resultobj;
34158 fail:
34159 return NULL;
34160 }
34161
34162
34163 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34164 PyObject *resultobj = 0;
34165 wxClipboard *arg1 = (wxClipboard *) 0 ;
34166 bool result;
34167 void *argp1 = 0 ;
34168 int res1 = 0 ;
34169 PyObject *swig_obj[1] ;
34170
34171 if (!args) SWIG_fail;
34172 swig_obj[0] = args;
34173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34174 if (!SWIG_IsOK(res1)) {
34175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34176 }
34177 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 result = (bool)(arg1)->Open();
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 {
34185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34186 }
34187 return resultobj;
34188 fail:
34189 return NULL;
34190 }
34191
34192
34193 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34194 PyObject *resultobj = 0;
34195 wxClipboard *arg1 = (wxClipboard *) 0 ;
34196 void *argp1 = 0 ;
34197 int res1 = 0 ;
34198 PyObject *swig_obj[1] ;
34199
34200 if (!args) SWIG_fail;
34201 swig_obj[0] = args;
34202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34203 if (!SWIG_IsOK(res1)) {
34204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34205 }
34206 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34207 {
34208 PyThreadState* __tstate = wxPyBeginAllowThreads();
34209 (arg1)->Close();
34210 wxPyEndAllowThreads(__tstate);
34211 if (PyErr_Occurred()) SWIG_fail;
34212 }
34213 resultobj = SWIG_Py_Void();
34214 return resultobj;
34215 fail:
34216 return NULL;
34217 }
34218
34219
34220 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34221 PyObject *resultobj = 0;
34222 wxClipboard *arg1 = (wxClipboard *) 0 ;
34223 bool result;
34224 void *argp1 = 0 ;
34225 int res1 = 0 ;
34226 PyObject *swig_obj[1] ;
34227
34228 if (!args) SWIG_fail;
34229 swig_obj[0] = args;
34230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34231 if (!SWIG_IsOK(res1)) {
34232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34233 }
34234 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34235 {
34236 PyThreadState* __tstate = wxPyBeginAllowThreads();
34237 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34238 wxPyEndAllowThreads(__tstate);
34239 if (PyErr_Occurred()) SWIG_fail;
34240 }
34241 {
34242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34243 }
34244 return resultobj;
34245 fail:
34246 return NULL;
34247 }
34248
34249
34250 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34251 PyObject *resultobj = 0;
34252 wxClipboard *arg1 = (wxClipboard *) 0 ;
34253 wxDataObject *arg2 = (wxDataObject *) 0 ;
34254 bool result;
34255 void *argp1 = 0 ;
34256 int res1 = 0 ;
34257 int res2 = 0 ;
34258 PyObject * obj0 = 0 ;
34259 PyObject * obj1 = 0 ;
34260 char * kwnames[] = {
34261 (char *) "self",(char *) "data", NULL
34262 };
34263
34264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34266 if (!SWIG_IsOK(res1)) {
34267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34268 }
34269 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34270 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34271 if (!SWIG_IsOK(res2)) {
34272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34273 }
34274 {
34275 PyThreadState* __tstate = wxPyBeginAllowThreads();
34276 result = (bool)(arg1)->AddData(arg2);
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 {
34281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34282 }
34283 return resultobj;
34284 fail:
34285 return NULL;
34286 }
34287
34288
34289 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34290 PyObject *resultobj = 0;
34291 wxClipboard *arg1 = (wxClipboard *) 0 ;
34292 wxDataObject *arg2 = (wxDataObject *) 0 ;
34293 bool result;
34294 void *argp1 = 0 ;
34295 int res1 = 0 ;
34296 int res2 = 0 ;
34297 PyObject * obj0 = 0 ;
34298 PyObject * obj1 = 0 ;
34299 char * kwnames[] = {
34300 (char *) "self",(char *) "data", NULL
34301 };
34302
34303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34305 if (!SWIG_IsOK(res1)) {
34306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34307 }
34308 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34309 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34310 if (!SWIG_IsOK(res2)) {
34311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34312 }
34313 {
34314 PyThreadState* __tstate = wxPyBeginAllowThreads();
34315 result = (bool)(arg1)->SetData(arg2);
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 {
34320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34321 }
34322 return resultobj;
34323 fail:
34324 return NULL;
34325 }
34326
34327
34328 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34329 PyObject *resultobj = 0;
34330 wxClipboard *arg1 = (wxClipboard *) 0 ;
34331 wxDataFormat *arg2 = 0 ;
34332 bool result;
34333 void *argp1 = 0 ;
34334 int res1 = 0 ;
34335 void *argp2 = 0 ;
34336 int res2 = 0 ;
34337 PyObject * obj0 = 0 ;
34338 PyObject * obj1 = 0 ;
34339 char * kwnames[] = {
34340 (char *) "self",(char *) "format", NULL
34341 };
34342
34343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34345 if (!SWIG_IsOK(res1)) {
34346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34347 }
34348 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34350 if (!SWIG_IsOK(res2)) {
34351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34352 }
34353 if (!argp2) {
34354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34355 }
34356 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34357 {
34358 PyThreadState* __tstate = wxPyBeginAllowThreads();
34359 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34360 wxPyEndAllowThreads(__tstate);
34361 if (PyErr_Occurred()) SWIG_fail;
34362 }
34363 {
34364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34365 }
34366 return resultobj;
34367 fail:
34368 return NULL;
34369 }
34370
34371
34372 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34373 PyObject *resultobj = 0;
34374 wxClipboard *arg1 = (wxClipboard *) 0 ;
34375 wxDataObject *arg2 = 0 ;
34376 bool result;
34377 void *argp1 = 0 ;
34378 int res1 = 0 ;
34379 void *argp2 = 0 ;
34380 int res2 = 0 ;
34381 PyObject * obj0 = 0 ;
34382 PyObject * obj1 = 0 ;
34383 char * kwnames[] = {
34384 (char *) "self",(char *) "data", NULL
34385 };
34386
34387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34389 if (!SWIG_IsOK(res1)) {
34390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34391 }
34392 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34393 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34394 if (!SWIG_IsOK(res2)) {
34395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34396 }
34397 if (!argp2) {
34398 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34399 }
34400 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = (bool)(arg1)->GetData(*arg2);
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 {
34408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34409 }
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxClipboard *arg1 = (wxClipboard *) 0 ;
34419 void *argp1 = 0 ;
34420 int res1 = 0 ;
34421 PyObject *swig_obj[1] ;
34422
34423 if (!args) SWIG_fail;
34424 swig_obj[0] = args;
34425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34426 if (!SWIG_IsOK(res1)) {
34427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34428 }
34429 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 (arg1)->Clear();
34433 wxPyEndAllowThreads(__tstate);
34434 if (PyErr_Occurred()) SWIG_fail;
34435 }
34436 resultobj = SWIG_Py_Void();
34437 return resultobj;
34438 fail:
34439 return NULL;
34440 }
34441
34442
34443 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34444 PyObject *resultobj = 0;
34445 wxClipboard *arg1 = (wxClipboard *) 0 ;
34446 bool result;
34447 void *argp1 = 0 ;
34448 int res1 = 0 ;
34449 PyObject *swig_obj[1] ;
34450
34451 if (!args) SWIG_fail;
34452 swig_obj[0] = args;
34453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34454 if (!SWIG_IsOK(res1)) {
34455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34456 }
34457 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 result = (bool)(arg1)->Flush();
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 {
34465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34466 }
34467 return resultobj;
34468 fail:
34469 return NULL;
34470 }
34471
34472
34473 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34474 PyObject *resultobj = 0;
34475 wxClipboard *arg1 = (wxClipboard *) 0 ;
34476 bool arg2 = (bool) true ;
34477 void *argp1 = 0 ;
34478 int res1 = 0 ;
34479 bool val2 ;
34480 int ecode2 = 0 ;
34481 PyObject * obj0 = 0 ;
34482 PyObject * obj1 = 0 ;
34483 char * kwnames[] = {
34484 (char *) "self",(char *) "primary", NULL
34485 };
34486
34487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34489 if (!SWIG_IsOK(res1)) {
34490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34491 }
34492 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34493 if (obj1) {
34494 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34495 if (!SWIG_IsOK(ecode2)) {
34496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34497 }
34498 arg2 = static_cast< bool >(val2);
34499 }
34500 {
34501 PyThreadState* __tstate = wxPyBeginAllowThreads();
34502 (arg1)->UsePrimarySelection(arg2);
34503 wxPyEndAllowThreads(__tstate);
34504 if (PyErr_Occurred()) SWIG_fail;
34505 }
34506 resultobj = SWIG_Py_Void();
34507 return resultobj;
34508 fail:
34509 return NULL;
34510 }
34511
34512
34513 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34514 PyObject *resultobj = 0;
34515 wxClipboard *result = 0 ;
34516
34517 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34518 {
34519 PyThreadState* __tstate = wxPyBeginAllowThreads();
34520 result = (wxClipboard *)wxClipboard::Get();
34521 wxPyEndAllowThreads(__tstate);
34522 if (PyErr_Occurred()) SWIG_fail;
34523 }
34524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34525 return resultobj;
34526 fail:
34527 return NULL;
34528 }
34529
34530
34531 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34532 PyObject *obj;
34533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34534 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34535 return SWIG_Py_Void();
34536 }
34537
34538 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34539 return SWIG_Python_InitShadowInstance(args);
34540 }
34541
34542 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34543 PyObject *resultobj = 0;
34544 wxClipboard *arg1 = (wxClipboard *) NULL ;
34545 wxClipboardLocker *result = 0 ;
34546 void *argp1 = 0 ;
34547 int res1 = 0 ;
34548 PyObject * obj0 = 0 ;
34549 char * kwnames[] = {
34550 (char *) "clipboard", NULL
34551 };
34552
34553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34554 if (obj0) {
34555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34556 if (!SWIG_IsOK(res1)) {
34557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34558 }
34559 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34560 }
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34564 wxPyEndAllowThreads(__tstate);
34565 if (PyErr_Occurred()) SWIG_fail;
34566 }
34567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34568 return resultobj;
34569 fail:
34570 return NULL;
34571 }
34572
34573
34574 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34575 PyObject *resultobj = 0;
34576 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34577 void *argp1 = 0 ;
34578 int res1 = 0 ;
34579 PyObject *swig_obj[1] ;
34580
34581 if (!args) SWIG_fail;
34582 swig_obj[0] = args;
34583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34584 if (!SWIG_IsOK(res1)) {
34585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34586 }
34587 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34588 {
34589 PyThreadState* __tstate = wxPyBeginAllowThreads();
34590 delete arg1;
34591
34592 wxPyEndAllowThreads(__tstate);
34593 if (PyErr_Occurred()) SWIG_fail;
34594 }
34595 resultobj = SWIG_Py_Void();
34596 return resultobj;
34597 fail:
34598 return NULL;
34599 }
34600
34601
34602 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34603 PyObject *resultobj = 0;
34604 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34605 bool result;
34606 void *argp1 = 0 ;
34607 int res1 = 0 ;
34608 PyObject *swig_obj[1] ;
34609
34610 if (!args) SWIG_fail;
34611 swig_obj[0] = args;
34612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34615 }
34616 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34617 {
34618 PyThreadState* __tstate = wxPyBeginAllowThreads();
34619 result = (bool)wxClipboardLocker___nonzero__(arg1);
34620 wxPyEndAllowThreads(__tstate);
34621 if (PyErr_Occurred()) SWIG_fail;
34622 }
34623 {
34624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34625 }
34626 return resultobj;
34627 fail:
34628 return NULL;
34629 }
34630
34631
34632 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34633 PyObject *obj;
34634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34635 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34636 return SWIG_Py_Void();
34637 }
34638
34639 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34640 return SWIG_Python_InitShadowInstance(args);
34641 }
34642
34643 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34644 PyObject *resultobj = 0;
34645 int arg1 = (int) 0 ;
34646 int arg2 = (int) 0 ;
34647 int arg3 = (int) 0 ;
34648 int arg4 = (int) 0 ;
34649 wxVideoMode *result = 0 ;
34650 int val1 ;
34651 int ecode1 = 0 ;
34652 int val2 ;
34653 int ecode2 = 0 ;
34654 int val3 ;
34655 int ecode3 = 0 ;
34656 int val4 ;
34657 int ecode4 = 0 ;
34658 PyObject * obj0 = 0 ;
34659 PyObject * obj1 = 0 ;
34660 PyObject * obj2 = 0 ;
34661 PyObject * obj3 = 0 ;
34662 char * kwnames[] = {
34663 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34664 };
34665
34666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34667 if (obj0) {
34668 ecode1 = SWIG_AsVal_int(obj0, &val1);
34669 if (!SWIG_IsOK(ecode1)) {
34670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34671 }
34672 arg1 = static_cast< int >(val1);
34673 }
34674 if (obj1) {
34675 ecode2 = SWIG_AsVal_int(obj1, &val2);
34676 if (!SWIG_IsOK(ecode2)) {
34677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34678 }
34679 arg2 = static_cast< int >(val2);
34680 }
34681 if (obj2) {
34682 ecode3 = SWIG_AsVal_int(obj2, &val3);
34683 if (!SWIG_IsOK(ecode3)) {
34684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34685 }
34686 arg3 = static_cast< int >(val3);
34687 }
34688 if (obj3) {
34689 ecode4 = SWIG_AsVal_int(obj3, &val4);
34690 if (!SWIG_IsOK(ecode4)) {
34691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34692 }
34693 arg4 = static_cast< int >(val4);
34694 }
34695 {
34696 PyThreadState* __tstate = wxPyBeginAllowThreads();
34697 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34698 wxPyEndAllowThreads(__tstate);
34699 if (PyErr_Occurred()) SWIG_fail;
34700 }
34701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34702 return resultobj;
34703 fail:
34704 return NULL;
34705 }
34706
34707
34708 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34709 PyObject *resultobj = 0;
34710 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34711 void *argp1 = 0 ;
34712 int res1 = 0 ;
34713 PyObject *swig_obj[1] ;
34714
34715 if (!args) SWIG_fail;
34716 swig_obj[0] = args;
34717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34718 if (!SWIG_IsOK(res1)) {
34719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34720 }
34721 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34722 {
34723 PyThreadState* __tstate = wxPyBeginAllowThreads();
34724 delete arg1;
34725
34726 wxPyEndAllowThreads(__tstate);
34727 if (PyErr_Occurred()) SWIG_fail;
34728 }
34729 resultobj = SWIG_Py_Void();
34730 return resultobj;
34731 fail:
34732 return NULL;
34733 }
34734
34735
34736 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34737 PyObject *resultobj = 0;
34738 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34739 wxVideoMode *arg2 = 0 ;
34740 bool result;
34741 void *argp1 = 0 ;
34742 int res1 = 0 ;
34743 void *argp2 = 0 ;
34744 int res2 = 0 ;
34745 PyObject * obj0 = 0 ;
34746 PyObject * obj1 = 0 ;
34747 char * kwnames[] = {
34748 (char *) "self",(char *) "other", NULL
34749 };
34750
34751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34753 if (!SWIG_IsOK(res1)) {
34754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34755 }
34756 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34757 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34758 if (!SWIG_IsOK(res2)) {
34759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34760 }
34761 if (!argp2) {
34762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34763 }
34764 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34765 {
34766 PyThreadState* __tstate = wxPyBeginAllowThreads();
34767 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34768 wxPyEndAllowThreads(__tstate);
34769 if (PyErr_Occurred()) SWIG_fail;
34770 }
34771 {
34772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34773 }
34774 return resultobj;
34775 fail:
34776 return NULL;
34777 }
34778
34779
34780 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34781 PyObject *resultobj = 0;
34782 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34783 int result;
34784 void *argp1 = 0 ;
34785 int res1 = 0 ;
34786 PyObject *swig_obj[1] ;
34787
34788 if (!args) SWIG_fail;
34789 swig_obj[0] = args;
34790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34791 if (!SWIG_IsOK(res1)) {
34792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34793 }
34794 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34795 {
34796 PyThreadState* __tstate = wxPyBeginAllowThreads();
34797 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34798 wxPyEndAllowThreads(__tstate);
34799 if (PyErr_Occurred()) SWIG_fail;
34800 }
34801 resultobj = SWIG_From_int(static_cast< int >(result));
34802 return resultobj;
34803 fail:
34804 return NULL;
34805 }
34806
34807
34808 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34809 PyObject *resultobj = 0;
34810 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34811 int result;
34812 void *argp1 = 0 ;
34813 int res1 = 0 ;
34814 PyObject *swig_obj[1] ;
34815
34816 if (!args) SWIG_fail;
34817 swig_obj[0] = args;
34818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34819 if (!SWIG_IsOK(res1)) {
34820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34821 }
34822 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34823 {
34824 PyThreadState* __tstate = wxPyBeginAllowThreads();
34825 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 resultobj = SWIG_From_int(static_cast< int >(result));
34830 return resultobj;
34831 fail:
34832 return NULL;
34833 }
34834
34835
34836 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34837 PyObject *resultobj = 0;
34838 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34839 int result;
34840 void *argp1 = 0 ;
34841 int res1 = 0 ;
34842 PyObject *swig_obj[1] ;
34843
34844 if (!args) SWIG_fail;
34845 swig_obj[0] = args;
34846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34847 if (!SWIG_IsOK(res1)) {
34848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34849 }
34850 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34851 {
34852 PyThreadState* __tstate = wxPyBeginAllowThreads();
34853 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 resultobj = SWIG_From_int(static_cast< int >(result));
34858 return resultobj;
34859 fail:
34860 return NULL;
34861 }
34862
34863
34864 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34865 PyObject *resultobj = 0;
34866 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34867 bool result;
34868 void *argp1 = 0 ;
34869 int res1 = 0 ;
34870 PyObject *swig_obj[1] ;
34871
34872 if (!args) SWIG_fail;
34873 swig_obj[0] = args;
34874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34875 if (!SWIG_IsOK(res1)) {
34876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34877 }
34878 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34879 {
34880 PyThreadState* __tstate = wxPyBeginAllowThreads();
34881 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34882 wxPyEndAllowThreads(__tstate);
34883 if (PyErr_Occurred()) SWIG_fail;
34884 }
34885 {
34886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34887 }
34888 return resultobj;
34889 fail:
34890 return NULL;
34891 }
34892
34893
34894 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34895 PyObject *resultobj = 0;
34896 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34897 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34898 bool result;
34899 void *argp1 = 0 ;
34900 int res1 = 0 ;
34901 void *argp2 = 0 ;
34902 int res2 = 0 ;
34903 PyObject * obj0 = 0 ;
34904 PyObject * obj1 = 0 ;
34905 char * kwnames[] = {
34906 (char *) "self",(char *) "other", NULL
34907 };
34908
34909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34911 if (!SWIG_IsOK(res1)) {
34912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34913 }
34914 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34916 if (!SWIG_IsOK(res2)) {
34917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34918 }
34919 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34920 {
34921 PyThreadState* __tstate = wxPyBeginAllowThreads();
34922 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34923 wxPyEndAllowThreads(__tstate);
34924 if (PyErr_Occurred()) SWIG_fail;
34925 }
34926 {
34927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34928 }
34929 return resultobj;
34930 fail:
34931 return NULL;
34932 }
34933
34934
34935 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34936 PyObject *resultobj = 0;
34937 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34938 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34939 bool result;
34940 void *argp1 = 0 ;
34941 int res1 = 0 ;
34942 void *argp2 = 0 ;
34943 int res2 = 0 ;
34944 PyObject * obj0 = 0 ;
34945 PyObject * obj1 = 0 ;
34946 char * kwnames[] = {
34947 (char *) "self",(char *) "other", NULL
34948 };
34949
34950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34952 if (!SWIG_IsOK(res1)) {
34953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34954 }
34955 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34956 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34957 if (!SWIG_IsOK(res2)) {
34958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34959 }
34960 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34961 {
34962 PyThreadState* __tstate = wxPyBeginAllowThreads();
34963 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34964 wxPyEndAllowThreads(__tstate);
34965 if (PyErr_Occurred()) SWIG_fail;
34966 }
34967 {
34968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34969 }
34970 return resultobj;
34971 fail:
34972 return NULL;
34973 }
34974
34975
34976 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34977 PyObject *resultobj = 0;
34978 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34979 int arg2 ;
34980 void *argp1 = 0 ;
34981 int res1 = 0 ;
34982 int val2 ;
34983 int ecode2 = 0 ;
34984 PyObject *swig_obj[2] ;
34985
34986 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34988 if (!SWIG_IsOK(res1)) {
34989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34990 }
34991 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34992 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34993 if (!SWIG_IsOK(ecode2)) {
34994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34995 }
34996 arg2 = static_cast< int >(val2);
34997 if (arg1) (arg1)->w = arg2;
34998
34999 resultobj = SWIG_Py_Void();
35000 return resultobj;
35001 fail:
35002 return NULL;
35003 }
35004
35005
35006 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35007 PyObject *resultobj = 0;
35008 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35009 int result;
35010 void *argp1 = 0 ;
35011 int res1 = 0 ;
35012 PyObject *swig_obj[1] ;
35013
35014 if (!args) SWIG_fail;
35015 swig_obj[0] = args;
35016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35017 if (!SWIG_IsOK(res1)) {
35018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35019 }
35020 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35021 result = (int) ((arg1)->w);
35022 resultobj = SWIG_From_int(static_cast< int >(result));
35023 return resultobj;
35024 fail:
35025 return NULL;
35026 }
35027
35028
35029 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35030 PyObject *resultobj = 0;
35031 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35032 int arg2 ;
35033 void *argp1 = 0 ;
35034 int res1 = 0 ;
35035 int val2 ;
35036 int ecode2 = 0 ;
35037 PyObject *swig_obj[2] ;
35038
35039 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
35040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35041 if (!SWIG_IsOK(res1)) {
35042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35043 }
35044 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35045 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35046 if (!SWIG_IsOK(ecode2)) {
35047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
35048 }
35049 arg2 = static_cast< int >(val2);
35050 if (arg1) (arg1)->h = arg2;
35051
35052 resultobj = SWIG_Py_Void();
35053 return resultobj;
35054 fail:
35055 return NULL;
35056 }
35057
35058
35059 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35060 PyObject *resultobj = 0;
35061 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35062 int result;
35063 void *argp1 = 0 ;
35064 int res1 = 0 ;
35065 PyObject *swig_obj[1] ;
35066
35067 if (!args) SWIG_fail;
35068 swig_obj[0] = args;
35069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35070 if (!SWIG_IsOK(res1)) {
35071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35072 }
35073 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35074 result = (int) ((arg1)->h);
35075 resultobj = SWIG_From_int(static_cast< int >(result));
35076 return resultobj;
35077 fail:
35078 return NULL;
35079 }
35080
35081
35082 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35083 PyObject *resultobj = 0;
35084 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35085 int arg2 ;
35086 void *argp1 = 0 ;
35087 int res1 = 0 ;
35088 int val2 ;
35089 int ecode2 = 0 ;
35090 PyObject *swig_obj[2] ;
35091
35092 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
35093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35094 if (!SWIG_IsOK(res1)) {
35095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35096 }
35097 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35098 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35099 if (!SWIG_IsOK(ecode2)) {
35100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
35101 }
35102 arg2 = static_cast< int >(val2);
35103 if (arg1) (arg1)->bpp = arg2;
35104
35105 resultobj = SWIG_Py_Void();
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35113 PyObject *resultobj = 0;
35114 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35115 int result;
35116 void *argp1 = 0 ;
35117 int res1 = 0 ;
35118 PyObject *swig_obj[1] ;
35119
35120 if (!args) SWIG_fail;
35121 swig_obj[0] = args;
35122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35123 if (!SWIG_IsOK(res1)) {
35124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35125 }
35126 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35127 result = (int) ((arg1)->bpp);
35128 resultobj = SWIG_From_int(static_cast< int >(result));
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35138 int arg2 ;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 int val2 ;
35142 int ecode2 = 0 ;
35143 PyObject *swig_obj[2] ;
35144
35145 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35147 if (!SWIG_IsOK(res1)) {
35148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35149 }
35150 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35151 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35152 if (!SWIG_IsOK(ecode2)) {
35153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35154 }
35155 arg2 = static_cast< int >(val2);
35156 if (arg1) (arg1)->refresh = arg2;
35157
35158 resultobj = SWIG_Py_Void();
35159 return resultobj;
35160 fail:
35161 return NULL;
35162 }
35163
35164
35165 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35166 PyObject *resultobj = 0;
35167 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35168 int result;
35169 void *argp1 = 0 ;
35170 int res1 = 0 ;
35171 PyObject *swig_obj[1] ;
35172
35173 if (!args) SWIG_fail;
35174 swig_obj[0] = args;
35175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35176 if (!SWIG_IsOK(res1)) {
35177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35178 }
35179 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35180 result = (int) ((arg1)->refresh);
35181 resultobj = SWIG_From_int(static_cast< int >(result));
35182 return resultobj;
35183 fail:
35184 return NULL;
35185 }
35186
35187
35188 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35189 PyObject *obj;
35190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35191 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35192 return SWIG_Py_Void();
35193 }
35194
35195 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35196 return SWIG_Python_InitShadowInstance(args);
35197 }
35198
35199 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35200 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35201 return 1;
35202 }
35203
35204
35205 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35206 PyObject *pyobj = 0;
35207
35208 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35209 return pyobj;
35210 }
35211
35212
35213 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35214 PyObject *resultobj = 0;
35215 size_t arg1 = (size_t) 0 ;
35216 wxDisplay *result = 0 ;
35217 size_t val1 ;
35218 int ecode1 = 0 ;
35219 PyObject * obj0 = 0 ;
35220 char * kwnames[] = {
35221 (char *) "index", NULL
35222 };
35223
35224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35225 if (obj0) {
35226 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35227 if (!SWIG_IsOK(ecode1)) {
35228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35229 }
35230 arg1 = static_cast< size_t >(val1);
35231 }
35232 {
35233 PyThreadState* __tstate = wxPyBeginAllowThreads();
35234 result = (wxDisplay *)new wxDisplay(arg1);
35235 wxPyEndAllowThreads(__tstate);
35236 if (PyErr_Occurred()) SWIG_fail;
35237 }
35238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35239 return resultobj;
35240 fail:
35241 return NULL;
35242 }
35243
35244
35245 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35246 PyObject *resultobj = 0;
35247 wxDisplay *arg1 = (wxDisplay *) 0 ;
35248 void *argp1 = 0 ;
35249 int res1 = 0 ;
35250 PyObject *swig_obj[1] ;
35251
35252 if (!args) SWIG_fail;
35253 swig_obj[0] = args;
35254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35255 if (!SWIG_IsOK(res1)) {
35256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35257 }
35258 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35259 {
35260 PyThreadState* __tstate = wxPyBeginAllowThreads();
35261 delete arg1;
35262
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 resultobj = SWIG_Py_Void();
35267 return resultobj;
35268 fail:
35269 return NULL;
35270 }
35271
35272
35273 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35274 PyObject *resultobj = 0;
35275 size_t result;
35276
35277 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35278 {
35279 PyThreadState* __tstate = wxPyBeginAllowThreads();
35280 result = (size_t)wxDisplay::GetCount();
35281 wxPyEndAllowThreads(__tstate);
35282 if (PyErr_Occurred()) SWIG_fail;
35283 }
35284 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35292 PyObject *resultobj = 0;
35293 wxPoint *arg1 = 0 ;
35294 int result;
35295 wxPoint temp1 ;
35296 PyObject * obj0 = 0 ;
35297 char * kwnames[] = {
35298 (char *) "pt", NULL
35299 };
35300
35301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35302 {
35303 arg1 = &temp1;
35304 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35305 }
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35309 wxPyEndAllowThreads(__tstate);
35310 if (PyErr_Occurred()) SWIG_fail;
35311 }
35312 resultobj = SWIG_From_int(static_cast< int >(result));
35313 return resultobj;
35314 fail:
35315 return NULL;
35316 }
35317
35318
35319 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35320 PyObject *resultobj = 0;
35321 wxWindow *arg1 = (wxWindow *) 0 ;
35322 int result;
35323 void *argp1 = 0 ;
35324 int res1 = 0 ;
35325 PyObject * obj0 = 0 ;
35326 char * kwnames[] = {
35327 (char *) "window", NULL
35328 };
35329
35330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35332 if (!SWIG_IsOK(res1)) {
35333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35334 }
35335 arg1 = reinterpret_cast< wxWindow * >(argp1);
35336 {
35337 PyThreadState* __tstate = wxPyBeginAllowThreads();
35338 result = (int)wxDisplay::GetFromWindow(arg1);
35339 wxPyEndAllowThreads(__tstate);
35340 if (PyErr_Occurred()) SWIG_fail;
35341 }
35342 resultobj = SWIG_From_int(static_cast< int >(result));
35343 return resultobj;
35344 fail:
35345 return NULL;
35346 }
35347
35348
35349 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35350 PyObject *resultobj = 0;
35351 wxDisplay *arg1 = (wxDisplay *) 0 ;
35352 bool result;
35353 void *argp1 = 0 ;
35354 int res1 = 0 ;
35355 PyObject *swig_obj[1] ;
35356
35357 if (!args) SWIG_fail;
35358 swig_obj[0] = args;
35359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35360 if (!SWIG_IsOK(res1)) {
35361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35362 }
35363 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35364 {
35365 PyThreadState* __tstate = wxPyBeginAllowThreads();
35366 result = (bool)((wxDisplay const *)arg1)->IsOk();
35367 wxPyEndAllowThreads(__tstate);
35368 if (PyErr_Occurred()) SWIG_fail;
35369 }
35370 {
35371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35372 }
35373 return resultobj;
35374 fail:
35375 return NULL;
35376 }
35377
35378
35379 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35380 PyObject *resultobj = 0;
35381 wxDisplay *arg1 = (wxDisplay *) 0 ;
35382 wxRect result;
35383 void *argp1 = 0 ;
35384 int res1 = 0 ;
35385 PyObject *swig_obj[1] ;
35386
35387 if (!args) SWIG_fail;
35388 swig_obj[0] = args;
35389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35390 if (!SWIG_IsOK(res1)) {
35391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35392 }
35393 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35394 {
35395 PyThreadState* __tstate = wxPyBeginAllowThreads();
35396 result = ((wxDisplay const *)arg1)->GetGeometry();
35397 wxPyEndAllowThreads(__tstate);
35398 if (PyErr_Occurred()) SWIG_fail;
35399 }
35400 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35401 return resultobj;
35402 fail:
35403 return NULL;
35404 }
35405
35406
35407 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35408 PyObject *resultobj = 0;
35409 wxDisplay *arg1 = (wxDisplay *) 0 ;
35410 wxRect result;
35411 void *argp1 = 0 ;
35412 int res1 = 0 ;
35413 PyObject *swig_obj[1] ;
35414
35415 if (!args) SWIG_fail;
35416 swig_obj[0] = args;
35417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35418 if (!SWIG_IsOK(res1)) {
35419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35420 }
35421 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35422 {
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 result = ((wxDisplay const *)arg1)->GetClientArea();
35425 wxPyEndAllowThreads(__tstate);
35426 if (PyErr_Occurred()) SWIG_fail;
35427 }
35428 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35436 PyObject *resultobj = 0;
35437 wxDisplay *arg1 = (wxDisplay *) 0 ;
35438 wxString result;
35439 void *argp1 = 0 ;
35440 int res1 = 0 ;
35441 PyObject *swig_obj[1] ;
35442
35443 if (!args) SWIG_fail;
35444 swig_obj[0] = args;
35445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35446 if (!SWIG_IsOK(res1)) {
35447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35448 }
35449 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35450 {
35451 PyThreadState* __tstate = wxPyBeginAllowThreads();
35452 result = ((wxDisplay const *)arg1)->GetName();
35453 wxPyEndAllowThreads(__tstate);
35454 if (PyErr_Occurred()) SWIG_fail;
35455 }
35456 {
35457 #if wxUSE_UNICODE
35458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35459 #else
35460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35461 #endif
35462 }
35463 return resultobj;
35464 fail:
35465 return NULL;
35466 }
35467
35468
35469 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35470 PyObject *resultobj = 0;
35471 wxDisplay *arg1 = (wxDisplay *) 0 ;
35472 bool 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_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35482 }
35483 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35487 wxPyEndAllowThreads(__tstate);
35488 if (PyErr_Occurred()) SWIG_fail;
35489 }
35490 {
35491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35492 }
35493 return resultobj;
35494 fail:
35495 return NULL;
35496 }
35497
35498
35499 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35500 PyObject *resultobj = 0;
35501 wxDisplay *arg1 = (wxDisplay *) 0 ;
35502 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35503 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35504 PyObject *result = 0 ;
35505 void *argp1 = 0 ;
35506 int res1 = 0 ;
35507 void *argp2 = 0 ;
35508 int res2 = 0 ;
35509 PyObject * obj0 = 0 ;
35510 PyObject * obj1 = 0 ;
35511 char * kwnames[] = {
35512 (char *) "self",(char *) "mode", NULL
35513 };
35514
35515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35517 if (!SWIG_IsOK(res1)) {
35518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35519 }
35520 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35521 if (obj1) {
35522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35523 if (!SWIG_IsOK(res2)) {
35524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35525 }
35526 if (!argp2) {
35527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35528 }
35529 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35530 }
35531 {
35532 PyThreadState* __tstate = wxPyBeginAllowThreads();
35533 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35534 wxPyEndAllowThreads(__tstate);
35535 if (PyErr_Occurred()) SWIG_fail;
35536 }
35537 resultobj = result;
35538 return resultobj;
35539 fail:
35540 return NULL;
35541 }
35542
35543
35544 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35545 PyObject *resultobj = 0;
35546 wxDisplay *arg1 = (wxDisplay *) 0 ;
35547 wxVideoMode result;
35548 void *argp1 = 0 ;
35549 int res1 = 0 ;
35550 PyObject *swig_obj[1] ;
35551
35552 if (!args) SWIG_fail;
35553 swig_obj[0] = args;
35554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35555 if (!SWIG_IsOK(res1)) {
35556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35557 }
35558 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35559 {
35560 PyThreadState* __tstate = wxPyBeginAllowThreads();
35561 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35562 wxPyEndAllowThreads(__tstate);
35563 if (PyErr_Occurred()) SWIG_fail;
35564 }
35565 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35566 return resultobj;
35567 fail:
35568 return NULL;
35569 }
35570
35571
35572 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35573 PyObject *resultobj = 0;
35574 wxDisplay *arg1 = (wxDisplay *) 0 ;
35575 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35576 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35577 bool result;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 void *argp2 = 0 ;
35581 int res2 = 0 ;
35582 PyObject * obj0 = 0 ;
35583 PyObject * obj1 = 0 ;
35584 char * kwnames[] = {
35585 (char *) "self",(char *) "mode", NULL
35586 };
35587
35588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35590 if (!SWIG_IsOK(res1)) {
35591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35592 }
35593 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35594 if (obj1) {
35595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35596 if (!SWIG_IsOK(res2)) {
35597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35598 }
35599 if (!argp2) {
35600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35601 }
35602 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35603 }
35604 {
35605 PyThreadState* __tstate = wxPyBeginAllowThreads();
35606 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35607 wxPyEndAllowThreads(__tstate);
35608 if (PyErr_Occurred()) SWIG_fail;
35609 }
35610 {
35611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35612 }
35613 return resultobj;
35614 fail:
35615 return NULL;
35616 }
35617
35618
35619 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35620 PyObject *resultobj = 0;
35621 wxDisplay *arg1 = (wxDisplay *) 0 ;
35622 void *argp1 = 0 ;
35623 int res1 = 0 ;
35624 PyObject *swig_obj[1] ;
35625
35626 if (!args) SWIG_fail;
35627 swig_obj[0] = args;
35628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35629 if (!SWIG_IsOK(res1)) {
35630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35631 }
35632 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35633 {
35634 PyThreadState* __tstate = wxPyBeginAllowThreads();
35635 wxDisplay_ResetMode(arg1);
35636 wxPyEndAllowThreads(__tstate);
35637 if (PyErr_Occurred()) SWIG_fail;
35638 }
35639 resultobj = SWIG_Py_Void();
35640 return resultobj;
35641 fail:
35642 return NULL;
35643 }
35644
35645
35646 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35647 PyObject *obj;
35648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35649 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35650 return SWIG_Py_Void();
35651 }
35652
35653 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35654 return SWIG_Python_InitShadowInstance(args);
35655 }
35656
35657 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35658 PyObject *resultobj = 0;
35659 wxStandardPaths *result = 0 ;
35660
35661 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35662 {
35663 PyThreadState* __tstate = wxPyBeginAllowThreads();
35664 result = (wxStandardPaths *)wxStandardPaths_Get();
35665 wxPyEndAllowThreads(__tstate);
35666 if (PyErr_Occurred()) SWIG_fail;
35667 }
35668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35669 return resultobj;
35670 fail:
35671 return NULL;
35672 }
35673
35674
35675 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35676 PyObject *resultobj = 0;
35677 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35678 wxString result;
35679 void *argp1 = 0 ;
35680 int res1 = 0 ;
35681 PyObject *swig_obj[1] ;
35682
35683 if (!args) SWIG_fail;
35684 swig_obj[0] = args;
35685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35686 if (!SWIG_IsOK(res1)) {
35687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35688 }
35689 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35690 {
35691 PyThreadState* __tstate = wxPyBeginAllowThreads();
35692 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35693 wxPyEndAllowThreads(__tstate);
35694 if (PyErr_Occurred()) SWIG_fail;
35695 }
35696 {
35697 #if wxUSE_UNICODE
35698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35699 #else
35700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35701 #endif
35702 }
35703 return resultobj;
35704 fail:
35705 return NULL;
35706 }
35707
35708
35709 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35710 PyObject *resultobj = 0;
35711 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35712 wxString result;
35713 void *argp1 = 0 ;
35714 int res1 = 0 ;
35715 PyObject *swig_obj[1] ;
35716
35717 if (!args) SWIG_fail;
35718 swig_obj[0] = args;
35719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35720 if (!SWIG_IsOK(res1)) {
35721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35722 }
35723 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35724 {
35725 PyThreadState* __tstate = wxPyBeginAllowThreads();
35726 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 {
35731 #if wxUSE_UNICODE
35732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35733 #else
35734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35735 #endif
35736 }
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35744 PyObject *resultobj = 0;
35745 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35746 wxString result;
35747 void *argp1 = 0 ;
35748 int res1 = 0 ;
35749 PyObject *swig_obj[1] ;
35750
35751 if (!args) SWIG_fail;
35752 swig_obj[0] = args;
35753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35754 if (!SWIG_IsOK(res1)) {
35755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35756 }
35757 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35758 {
35759 PyThreadState* __tstate = wxPyBeginAllowThreads();
35760 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 {
35765 #if wxUSE_UNICODE
35766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35767 #else
35768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35769 #endif
35770 }
35771 return resultobj;
35772 fail:
35773 return NULL;
35774 }
35775
35776
35777 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35778 PyObject *resultobj = 0;
35779 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35780 wxString result;
35781 void *argp1 = 0 ;
35782 int res1 = 0 ;
35783 PyObject *swig_obj[1] ;
35784
35785 if (!args) SWIG_fail;
35786 swig_obj[0] = args;
35787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35788 if (!SWIG_IsOK(res1)) {
35789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35790 }
35791 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35792 {
35793 PyThreadState* __tstate = wxPyBeginAllowThreads();
35794 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35795 wxPyEndAllowThreads(__tstate);
35796 if (PyErr_Occurred()) SWIG_fail;
35797 }
35798 {
35799 #if wxUSE_UNICODE
35800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35801 #else
35802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35803 #endif
35804 }
35805 return resultobj;
35806 fail:
35807 return NULL;
35808 }
35809
35810
35811 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35812 PyObject *resultobj = 0;
35813 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35814 wxString result;
35815 void *argp1 = 0 ;
35816 int res1 = 0 ;
35817 PyObject *swig_obj[1] ;
35818
35819 if (!args) SWIG_fail;
35820 swig_obj[0] = args;
35821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35822 if (!SWIG_IsOK(res1)) {
35823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35824 }
35825 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35826 {
35827 PyThreadState* __tstate = wxPyBeginAllowThreads();
35828 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 {
35833 #if wxUSE_UNICODE
35834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35835 #else
35836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35837 #endif
35838 }
35839 return resultobj;
35840 fail:
35841 return NULL;
35842 }
35843
35844
35845 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35846 PyObject *resultobj = 0;
35847 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35848 wxString result;
35849 void *argp1 = 0 ;
35850 int res1 = 0 ;
35851 PyObject *swig_obj[1] ;
35852
35853 if (!args) SWIG_fail;
35854 swig_obj[0] = args;
35855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35856 if (!SWIG_IsOK(res1)) {
35857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35858 }
35859 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35860 {
35861 PyThreadState* __tstate = wxPyBeginAllowThreads();
35862 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 {
35867 #if wxUSE_UNICODE
35868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35869 #else
35870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35871 #endif
35872 }
35873 return resultobj;
35874 fail:
35875 return NULL;
35876 }
35877
35878
35879 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35880 PyObject *resultobj = 0;
35881 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35882 wxString result;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 PyObject *swig_obj[1] ;
35886
35887 if (!args) SWIG_fail;
35888 swig_obj[0] = args;
35889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35890 if (!SWIG_IsOK(res1)) {
35891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35892 }
35893 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35894 {
35895 PyThreadState* __tstate = wxPyBeginAllowThreads();
35896 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35897 wxPyEndAllowThreads(__tstate);
35898 if (PyErr_Occurred()) SWIG_fail;
35899 }
35900 {
35901 #if wxUSE_UNICODE
35902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35903 #else
35904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35905 #endif
35906 }
35907 return resultobj;
35908 fail:
35909 return NULL;
35910 }
35911
35912
35913 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35914 PyObject *resultobj = 0;
35915 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35916 wxString result;
35917 void *argp1 = 0 ;
35918 int res1 = 0 ;
35919 PyObject *swig_obj[1] ;
35920
35921 if (!args) SWIG_fail;
35922 swig_obj[0] = args;
35923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35924 if (!SWIG_IsOK(res1)) {
35925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35926 }
35927 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35928 {
35929 PyThreadState* __tstate = wxPyBeginAllowThreads();
35930 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 {
35935 #if wxUSE_UNICODE
35936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35937 #else
35938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35939 #endif
35940 }
35941 return resultobj;
35942 fail:
35943 return NULL;
35944 }
35945
35946
35947 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35948 PyObject *resultobj = 0;
35949 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35950 wxString *arg2 = 0 ;
35951 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35952 wxString result;
35953 void *argp1 = 0 ;
35954 int res1 = 0 ;
35955 bool temp2 = false ;
35956 int val3 ;
35957 int ecode3 = 0 ;
35958 PyObject * obj0 = 0 ;
35959 PyObject * obj1 = 0 ;
35960 PyObject * obj2 = 0 ;
35961 char * kwnames[] = {
35962 (char *) "self",(char *) "lang",(char *) "category", NULL
35963 };
35964
35965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35967 if (!SWIG_IsOK(res1)) {
35968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35969 }
35970 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35971 {
35972 arg2 = wxString_in_helper(obj1);
35973 if (arg2 == NULL) SWIG_fail;
35974 temp2 = true;
35975 }
35976 if (obj2) {
35977 ecode3 = SWIG_AsVal_int(obj2, &val3);
35978 if (!SWIG_IsOK(ecode3)) {
35979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35980 }
35981 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 {
35990 #if wxUSE_UNICODE
35991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35992 #else
35993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35994 #endif
35995 }
35996 {
35997 if (temp2)
35998 delete arg2;
35999 }
36000 return resultobj;
36001 fail:
36002 {
36003 if (temp2)
36004 delete arg2;
36005 }
36006 return NULL;
36007 }
36008
36009
36010 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36011 PyObject *resultobj = 0;
36012 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36013 wxString result;
36014 void *argp1 = 0 ;
36015 int res1 = 0 ;
36016 PyObject *swig_obj[1] ;
36017
36018 if (!args) SWIG_fail;
36019 swig_obj[0] = args;
36020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36021 if (!SWIG_IsOK(res1)) {
36022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36023 }
36024 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36025 {
36026 PyThreadState* __tstate = wxPyBeginAllowThreads();
36027 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
36028 wxPyEndAllowThreads(__tstate);
36029 if (PyErr_Occurred()) SWIG_fail;
36030 }
36031 {
36032 #if wxUSE_UNICODE
36033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36034 #else
36035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36036 #endif
36037 }
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36045 PyObject *resultobj = 0;
36046 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36047 wxString *arg2 = 0 ;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050 bool temp2 = false ;
36051 PyObject * obj0 = 0 ;
36052 PyObject * obj1 = 0 ;
36053 char * kwnames[] = {
36054 (char *) "self",(char *) "prefix", NULL
36055 };
36056
36057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
36058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36059 if (!SWIG_IsOK(res1)) {
36060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36061 }
36062 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36063 {
36064 arg2 = wxString_in_helper(obj1);
36065 if (arg2 == NULL) SWIG_fail;
36066 temp2 = true;
36067 }
36068 {
36069 PyThreadState* __tstate = wxPyBeginAllowThreads();
36070 (arg1)->SetInstallPrefix((wxString const &)*arg2);
36071 wxPyEndAllowThreads(__tstate);
36072 if (PyErr_Occurred()) SWIG_fail;
36073 }
36074 resultobj = SWIG_Py_Void();
36075 {
36076 if (temp2)
36077 delete arg2;
36078 }
36079 return resultobj;
36080 fail:
36081 {
36082 if (temp2)
36083 delete arg2;
36084 }
36085 return NULL;
36086 }
36087
36088
36089 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36090 PyObject *resultobj = 0;
36091 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36092 wxString result;
36093 void *argp1 = 0 ;
36094 int res1 = 0 ;
36095 PyObject *swig_obj[1] ;
36096
36097 if (!args) SWIG_fail;
36098 swig_obj[0] = args;
36099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36100 if (!SWIG_IsOK(res1)) {
36101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36102 }
36103 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36104 {
36105 PyThreadState* __tstate = wxPyBeginAllowThreads();
36106 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
36107 wxPyEndAllowThreads(__tstate);
36108 if (PyErr_Occurred()) SWIG_fail;
36109 }
36110 {
36111 #if wxUSE_UNICODE
36112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36113 #else
36114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36115 #endif
36116 }
36117 return resultobj;
36118 fail:
36119 return NULL;
36120 }
36121
36122
36123 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36124 PyObject *obj;
36125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36126 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36127 return SWIG_Py_Void();
36128 }
36129
36130 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36131 PyObject *resultobj = 0;
36132 wxEventType arg1 ;
36133 wxPowerEvent *result = 0 ;
36134 int val1 ;
36135 int ecode1 = 0 ;
36136 PyObject * obj0 = 0 ;
36137 char * kwnames[] = {
36138 (char *) "evtType", NULL
36139 };
36140
36141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36142 ecode1 = SWIG_AsVal_int(obj0, &val1);
36143 if (!SWIG_IsOK(ecode1)) {
36144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36145 }
36146 arg1 = static_cast< wxEventType >(val1);
36147 {
36148 PyThreadState* __tstate = wxPyBeginAllowThreads();
36149 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36150 wxPyEndAllowThreads(__tstate);
36151 if (PyErr_Occurred()) SWIG_fail;
36152 }
36153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36154 return resultobj;
36155 fail:
36156 return NULL;
36157 }
36158
36159
36160 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36161 PyObject *resultobj = 0;
36162 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36163 void *argp1 = 0 ;
36164 int res1 = 0 ;
36165 PyObject *swig_obj[1] ;
36166
36167 if (!args) SWIG_fail;
36168 swig_obj[0] = args;
36169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36170 if (!SWIG_IsOK(res1)) {
36171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36172 }
36173 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36174 {
36175 PyThreadState* __tstate = wxPyBeginAllowThreads();
36176 (arg1)->Veto();
36177 wxPyEndAllowThreads(__tstate);
36178 if (PyErr_Occurred()) SWIG_fail;
36179 }
36180 resultobj = SWIG_Py_Void();
36181 return resultobj;
36182 fail:
36183 return NULL;
36184 }
36185
36186
36187 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36188 PyObject *resultobj = 0;
36189 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36190 bool result;
36191 void *argp1 = 0 ;
36192 int res1 = 0 ;
36193 PyObject *swig_obj[1] ;
36194
36195 if (!args) SWIG_fail;
36196 swig_obj[0] = args;
36197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36198 if (!SWIG_IsOK(res1)) {
36199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36200 }
36201 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36202 {
36203 PyThreadState* __tstate = wxPyBeginAllowThreads();
36204 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36205 wxPyEndAllowThreads(__tstate);
36206 if (PyErr_Occurred()) SWIG_fail;
36207 }
36208 {
36209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36210 }
36211 return resultobj;
36212 fail:
36213 return NULL;
36214 }
36215
36216
36217 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36218 PyObject *obj;
36219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36220 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36221 return SWIG_Py_Void();
36222 }
36223
36224 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36225 return SWIG_Python_InitShadowInstance(args);
36226 }
36227
36228 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36229 PyObject *resultobj = 0;
36230 wxPowerType result;
36231
36232 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36233 {
36234 PyThreadState* __tstate = wxPyBeginAllowThreads();
36235 result = (wxPowerType)wxGetPowerType();
36236 wxPyEndAllowThreads(__tstate);
36237 if (PyErr_Occurred()) SWIG_fail;
36238 }
36239 resultobj = SWIG_From_int(static_cast< int >(result));
36240 return resultobj;
36241 fail:
36242 return NULL;
36243 }
36244
36245
36246 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36247 PyObject *resultobj = 0;
36248 wxBatteryState result;
36249
36250 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36251 {
36252 PyThreadState* __tstate = wxPyBeginAllowThreads();
36253 result = (wxBatteryState)wxGetBatteryState();
36254 wxPyEndAllowThreads(__tstate);
36255 if (PyErr_Occurred()) SWIG_fail;
36256 }
36257 resultobj = SWIG_From_int(static_cast< int >(result));
36258 return resultobj;
36259 fail:
36260 return NULL;
36261 }
36262
36263
36264 static PyMethodDef SwigMethods[] = {
36265 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36267 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36268 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36270 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36271 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36272 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36273 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36274 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36275 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36277 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36280 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36281 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36282 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36284 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36288 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36289 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36291 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36292 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36293 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36294 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36295 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36296 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36297 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36298 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36302 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36304 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36305 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36306 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36307 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36308 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36309 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36310 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36311 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36312 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36317 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36323 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36324 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36325 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36326 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36327 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36328 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36329 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36330 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36331 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36332 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36333 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36334 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36335 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36336 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36337 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36343 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36344 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36345 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36346 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36347 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36348 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36349 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36350 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36351 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36352 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36353 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36354 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36357 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36358 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36364 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36365 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36366 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36367 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36368 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36369 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36370 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36371 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36372 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36373 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36374 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36376 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36378 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36379 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36382 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36383 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36385 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36386 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36387 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36388 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36389 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36390 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36391 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36392 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36393 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36396 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36397 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36398 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36399 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36400 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36402 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36403 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36405 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36406 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36407 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36409 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36410 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36411 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36412 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36413 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36414 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36415 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36416 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36418 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36419 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36420 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36421 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36422 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36424 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36425 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36426 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36427 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36432 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36434 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36435 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36436 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36437 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36438 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36439 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36440 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36442 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36443 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36444 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36446 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36447 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36448 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36449 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36450 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36451 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36453 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36454 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36455 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36458 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36461 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36463 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36464 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36465 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36466 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36467 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36468 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36469 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36470 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36472 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36473 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36474 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36475 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36476 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36478 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36479 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36480 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36481 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36482 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36483 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36485 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36486 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36487 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36489 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36490 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36493 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
36495 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36496 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36499 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36500 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36501 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36502 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36503 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36504 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36505 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36506 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36507 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36508 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36509 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36510 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36511 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36512 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36513 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36514 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36515 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36516 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36517 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36518 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36519 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36522 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36523 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36524 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36525 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36526 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36527 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36531 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36532 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36533 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36534 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36535 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36536 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36537 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36538 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36539 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36540 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36541 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36546 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36552 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36554 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36555 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36556 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36557 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36558 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36560 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36561 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36563 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36565 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36568 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36569 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36570 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36571 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36572 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36573 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36574 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36575 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36576 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36577 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36578 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36579 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36580 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36581 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36582 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36583 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36584 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36585 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36586 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36587 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36588 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36592 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36593 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36594 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36595 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36596 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36597 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36598 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36599 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36600 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36601 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36603 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36604 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36605 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36606 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36607 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36608 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36609 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36610 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36611 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36612 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36613 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36614 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36615 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36616 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36617 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36618 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36619 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36620 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36621 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36622 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36623 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36624 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36625 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36626 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36627 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36628 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36629 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36630 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36631 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36632 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36634 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36635 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36636 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36638 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36639 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36640 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36641 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36642 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36648 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36649 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36650 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36654 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36655 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36656 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36657 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36658 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36659 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36661 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36662 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36664 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36665 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36666 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36669 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36670 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36673 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36674 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36675 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36676 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36677 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36678 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36679 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36680 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36681 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36682 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36683 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36684 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36685 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36686 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36687 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36688 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36689 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36690 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36691 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36692 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36697 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36699 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36700 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36702 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36704 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36709 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36710 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36713 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36714 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36715 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36716 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36717 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36718 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36719 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36720 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36721 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36723 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36725 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36726 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36727 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36728 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36731 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36732 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36734 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36735 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36737 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36738 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36742 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36758 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36760 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36762 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36763 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36764 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36765 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36769 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36770 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36771 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36772 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36773 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36774 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36775 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36776 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36777 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36778 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36780 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36781 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36782 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36783 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36784 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36786 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36788 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36789 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36790 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36797 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36801 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36802 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36803 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36804 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36805 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36810 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36811 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36814 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36816 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36825 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36826 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36827 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36834 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36838 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36840 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36841 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36842 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36843 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36844 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36845 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36846 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36847 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36848 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36849 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36850 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36854 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36856 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36857 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36858 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36864 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36865 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36866 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36871 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36872 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36874 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36875 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36877 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36878 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36881 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36882 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36883 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36884 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36885 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36886 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36889 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36891 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36896 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36898 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36899 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36900 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36901 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36902 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36903 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36904 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36905 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36906 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36907 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36908 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36909 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36910 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36911 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36912 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36913 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36914 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36915 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36916 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36917 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36918 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36919 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36920 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36922 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36923 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36926 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36927 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36928 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36929 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36930 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36931 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36933 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36935 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36936 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36938 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36939 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36940 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36941 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36942 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36943 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36944 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36945 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36946 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36947 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36948 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36949 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36950 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36951 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36952 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36953 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36954 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36955 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36956 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36957 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36958 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36959 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36960 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36961 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36962 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36963 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36964 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36965 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36966 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36967 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36968 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36969 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36970 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36971 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36972 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36973 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36974 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36975 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36976 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36977 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36978 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36979 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36980 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36982 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36983 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36984 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36985 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36986 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36987 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36988 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36989 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36990 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36991 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36992 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36993 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36994 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36995 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36996 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36997 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36998 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36999 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
37000 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
37001 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
37002 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
37003 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37004 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
37005 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37006 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
37007 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
37008 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
37009 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37010 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
37011 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37012 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
37013 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37014 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
37015 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
37016 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37017 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
37018 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
37019 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37020 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37021 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
37022 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
37023 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
37024 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37025 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
37026 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
37027 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
37028 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37029 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
37030 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
37031 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
37032 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
37033 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
37034 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37035 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37036 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
37037 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
37038 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37039 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
37040 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37041 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
37042 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
37043 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37044 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37045 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
37046 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
37047 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
37048 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
37049 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
37050 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
37051 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
37052 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
37053 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37054 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
37055 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
37056 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
37057 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
37058 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
37059 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
37060 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
37061 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
37062 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
37063 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
37064 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
37065 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
37066 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
37067 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
37068 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37069 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
37070 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37071 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
37072 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37073 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37074 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
37075 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
37076 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
37077 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37078 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37079 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
37080 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
37081 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37082 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37083 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37084 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
37085 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37086 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
37087 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
37088 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
37089 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
37090 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
37091 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
37092 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37093 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
37094 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37095 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37096 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
37097 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37098 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37099 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
37100 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
37101 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
37102 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37103 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
37104 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37105 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37106 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
37107 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37108 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37109 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
37110 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
37111 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
37112 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
37113 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
37114 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
37115 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
37116 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
37117 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37118 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37119 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37120 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37121 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37122 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37123 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37124 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37125 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37126 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37127 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37128 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37129 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37130 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37131 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37132 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37133 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37134 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37135 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37136 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37137 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37138 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37139 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37140 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37141 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37142 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37143 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37144 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37145 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37146 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37147 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37148 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37149 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37150 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37151 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37152 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37153 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37154 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37155 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37156 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37157 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37158 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37159 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37160 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37161 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37162 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37163 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37164 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37165 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37166 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37167 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37168 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37169 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37170 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37171 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37172 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37173 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37174 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37175 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37176 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37177 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37178 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37179 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37180 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37181 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37182 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37183 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37184 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37185 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37186 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37187 { NULL, NULL, 0, NULL }
37188 };
37189
37190
37191 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37192
37193 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37194 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37195 }
37196 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37197 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37198 }
37199 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37200 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37201 }
37202 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37203 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37204 }
37205 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37206 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37207 }
37208 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37209 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37210 }
37211 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37212 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37213 }
37214 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37215 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37216 }
37217 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37218 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37219 }
37220 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37221 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37222 }
37223 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37224 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37225 }
37226 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37227 return (void *)((wxEvent *) ((wxPyEvent *) x));
37228 }
37229 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37230 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37231 }
37232 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37233 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37234 }
37235 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37236 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37237 }
37238 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37239 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37240 }
37241 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37242 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37243 }
37244 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37245 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37246 }
37247 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37248 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37249 }
37250 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37251 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37252 }
37253 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37254 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37255 }
37256 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37257 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37258 }
37259 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37260 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37261 }
37262 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37263 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37264 }
37265 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37266 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37267 }
37268 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37269 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37270 }
37271 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37272 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37273 }
37274 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37275 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37276 }
37277 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37278 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37279 }
37280 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37281 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37282 }
37283 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37284 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37285 }
37286 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37287 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37288 }
37289 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37290 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37291 }
37292 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37293 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37294 }
37295 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37296 return (void *)((wxEvent *) ((wxShowEvent *) x));
37297 }
37298 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37299 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37300 }
37301 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37302 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37303 }
37304 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37305 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37306 }
37307 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37308 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37309 }
37310 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37311 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37312 }
37313 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37314 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37315 }
37316 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37317 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37318 }
37319 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37320 return (void *)((wxConfigBase *) ((wxConfig *) x));
37321 }
37322 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37323 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37324 }
37325 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37326 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37327 }
37328 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37329 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37330 }
37331 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37332 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37333 }
37334 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37335 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37336 }
37337 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37338 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37339 }
37340 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37341 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37342 }
37343 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37344 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37345 }
37346 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37347 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37348 }
37349 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37350 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37351 }
37352 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37353 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37354 }
37355 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37356 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37357 }
37358 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37359 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37360 }
37361 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37362 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37363 }
37364 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37365 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37366 }
37367 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37368 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37369 }
37370 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37371 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37372 }
37373 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37374 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37375 }
37376 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37377 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37378 }
37379 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37380 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37381 }
37382 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37383 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37384 }
37385 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37386 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37387 }
37388 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37389 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37390 }
37391 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37392 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37393 }
37394 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37395 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37396 }
37397 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37398 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37399 }
37400 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37401 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37402 }
37403 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37404 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37405 }
37406 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37407 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37408 }
37409 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37410 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37411 }
37412 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37413 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37414 }
37415 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37416 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37417 }
37418 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37419 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37420 }
37421 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37422 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37423 }
37424 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37425 return (void *)((wxObject *) ((wxSizerItem *) x));
37426 }
37427 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37428 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37429 }
37430 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37431 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37432 }
37433 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37434 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37435 }
37436 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37437 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37438 }
37439 static void *_p_wxSizerTo_p_wxObject(void *x) {
37440 return (void *)((wxObject *) ((wxSizer *) x));
37441 }
37442 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37443 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37444 }
37445 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37446 return (void *)((wxObject *) ((wxFileHistory *) x));
37447 }
37448 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37449 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37450 }
37451 static void *_p_wxEventTo_p_wxObject(void *x) {
37452 return (void *)((wxObject *) ((wxEvent *) x));
37453 }
37454 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37455 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37456 }
37457 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37458 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37459 }
37460 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37461 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37462 }
37463 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37464 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37465 }
37466 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37467 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37468 }
37469 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37470 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37471 }
37472 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37473 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37474 }
37475 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37476 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37477 }
37478 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37479 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37480 }
37481 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37482 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37483 }
37484 static void *_p_wxControlTo_p_wxObject(void *x) {
37485 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37486 }
37487 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37488 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37489 }
37490 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37491 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37492 }
37493 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37494 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37495 }
37496 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37497 return (void *)((wxObject *) ((wxFSFile *) x));
37498 }
37499 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37500 return (void *)((wxObject *) ((wxClipboard *) x));
37501 }
37502 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37503 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37504 }
37505 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37506 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37507 }
37508 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37509 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37510 }
37511 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37512 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37513 }
37514 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37515 return (void *)((wxObject *) ((wxToolTip *) x));
37516 }
37517 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37518 return (void *)((wxObject *) ((wxMenuItem *) x));
37519 }
37520 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37521 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37522 }
37523 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37524 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37525 }
37526 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37527 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37528 }
37529 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37530 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37531 }
37532 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37533 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37534 }
37535 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37536 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37537 }
37538 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37539 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37540 }
37541 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37542 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37543 }
37544 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37545 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37546 }
37547 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37548 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37549 }
37550 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37551 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37552 }
37553 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37554 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37555 }
37556 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37557 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37558 }
37559 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37560 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37561 }
37562 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37563 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37564 }
37565 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37566 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37567 }
37568 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37569 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37570 }
37571 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37572 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37573 }
37574 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37575 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37576 }
37577 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37578 return (void *)((wxObject *) ((wxImageHandler *) x));
37579 }
37580 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37581 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37582 }
37583 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37584 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37585 }
37586 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37587 return (void *)((wxObject *) ((wxEvtHandler *) x));
37588 }
37589 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37590 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37591 }
37592 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37593 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37594 }
37595 static void *_p_wxImageTo_p_wxObject(void *x) {
37596 return (void *)((wxObject *) ((wxImage *) x));
37597 }
37598 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37599 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37600 }
37601 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37602 return (void *)((wxObject *) ((wxSystemOptions *) x));
37603 }
37604 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37605 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37606 }
37607 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37608 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37609 }
37610 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37611 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37612 }
37613 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37614 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37615 }
37616 static void *_p_wxWindowTo_p_wxObject(void *x) {
37617 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37618 }
37619 static void *_p_wxMenuTo_p_wxObject(void *x) {
37620 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37621 }
37622 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37623 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37624 }
37625 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37626 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37627 }
37628 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37629 return (void *)((wxObject *) ((wxFileSystem *) x));
37630 }
37631 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37632 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37633 }
37634 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37635 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37636 }
37637 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37638 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37639 }
37640 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37641 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37642 }
37643 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37644 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37645 }
37646 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37647 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37648 }
37649 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37650 return (void *)((wxObject *) ((wxBusyInfo *) x));
37651 }
37652 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37653 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37654 }
37655 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37656 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37657 }
37658 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37659 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37660 }
37661 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37662 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37663 }
37664 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37665 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37666 }
37667 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37668 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37669 }
37670 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37671 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37672 }
37673 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37674 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37675 }
37676 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37677 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37678 }
37679 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37680 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37681 }
37682 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37683 return (void *)((wxLog *) ((wxLogBuffer *) x));
37684 }
37685 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37686 return (void *)((wxLog *) ((wxLogStderr *) x));
37687 }
37688 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37689 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37690 }
37691 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37692 return (void *)((wxLog *) ((wxLogWindow *) x));
37693 }
37694 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37695 return (void *)((wxLog *) ((wxLogChain *) x));
37696 }
37697 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37698 return (void *)((wxLog *) ((wxLogGui *) x));
37699 }
37700 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37701 return (void *)((wxLog *) ((wxPyLog *) x));
37702 }
37703 static void *_p_wxControlTo_p_wxWindow(void *x) {
37704 return (void *)((wxWindow *) ((wxControl *) x));
37705 }
37706 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37707 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37708 }
37709 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37710 return (void *)((wxWindow *) ((wxMenuBar *) x));
37711 }
37712 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37713 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37714 }
37715 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37716 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37717 }
37718 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37719 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};
37720 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37721 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37722 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37723 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37724 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37725 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37726 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37727 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37728 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37729 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37730 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37731 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37732 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37733 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37734 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37735 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37736 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37737 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37738 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37739 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37740 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37741 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37742 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37743 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37744 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37745 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37746 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37747 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37748 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37749 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37750 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37751 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37752 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37753 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37754 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37755 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37756 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37757 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37758 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37759 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37760 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37761 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37762 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37763 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37764 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37765 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37766 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37767 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37768 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37769 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37770 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37771 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37772 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37773 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37774 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37775 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37776 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37777 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37778 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37779 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37780 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37781 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37782 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37783 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37784 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37785 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37786 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37787 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37788 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37789 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37790 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37791 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37792 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37793 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37794 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37795 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37796 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37797 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37798 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37799 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37800 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37801 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37802 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37803 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37804 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37805 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37806 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37807 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37808 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37809 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37810 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37811 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37812 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37813 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37814 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37815 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37816 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37817 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37818 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37819 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37820 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37821 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37822 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37823 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37824 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37825 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37826 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37827 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37828 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37829 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37830 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37831 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37832 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37833 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37834 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37835 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37836 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37837 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37838 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37839 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37840 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37841 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37842 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37843 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37844 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37845 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37846 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37847 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37848 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37849 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37850 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37851 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37852 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37853 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37854 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37855 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37856 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37857 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37858 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37859 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37860 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37861 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37862 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37863 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37864 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37865 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37866 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37867 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37868 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37869 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37870 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37871 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37872 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37873 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37874 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37875 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37876 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37877 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37878 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37879 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37880 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37881 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37882 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37883 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37884 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37885 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37886 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37887 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37888
37889 static swig_type_info *swig_type_initial[] = {
37890 &_swigt__p_char,
37891 &_swigt__p_form_ops_t,
37892 &_swigt__p_int,
37893 &_swigt__p_unsigned_char,
37894 &_swigt__p_unsigned_int,
37895 &_swigt__p_unsigned_long,
37896 &_swigt__p_void,
37897 &_swigt__p_wxANIHandler,
37898 &_swigt__p_wxAcceleratorTable,
37899 &_swigt__p_wxActivateEvent,
37900 &_swigt__p_wxArrayString,
37901 &_swigt__p_wxBMPHandler,
37902 &_swigt__p_wxBitmap,
37903 &_swigt__p_wxBitmapDataObject,
37904 &_swigt__p_wxBoxSizer,
37905 &_swigt__p_wxBusyCursor,
37906 &_swigt__p_wxBusyInfo,
37907 &_swigt__p_wxCURHandler,
37908 &_swigt__p_wxCaret,
37909 &_swigt__p_wxChar,
37910 &_swigt__p_wxChildFocusEvent,
37911 &_swigt__p_wxClipboard,
37912 &_swigt__p_wxClipboardLocker,
37913 &_swigt__p_wxClipboardTextEvent,
37914 &_swigt__p_wxCloseEvent,
37915 &_swigt__p_wxColour,
37916 &_swigt__p_wxCommandEvent,
37917 &_swigt__p_wxConfig,
37918 &_swigt__p_wxConfigBase,
37919 &_swigt__p_wxConfigPathChanger,
37920 &_swigt__p_wxContextMenuEvent,
37921 &_swigt__p_wxControl,
37922 &_swigt__p_wxControlWithItems,
37923 &_swigt__p_wxCursor,
37924 &_swigt__p_wxCustomDataObject,
37925 &_swigt__p_wxDC,
37926 &_swigt__p_wxDataFormat,
37927 &_swigt__p_wxDataObject,
37928 &_swigt__p_wxDataObjectComposite,
37929 &_swigt__p_wxDataObjectSimple,
37930 &_swigt__p_wxDateEvent,
37931 &_swigt__p_wxDateSpan,
37932 &_swigt__p_wxDateTime,
37933 &_swigt__p_wxDateTime__TimeZone,
37934 &_swigt__p_wxDisplay,
37935 &_swigt__p_wxDisplayChangedEvent,
37936 &_swigt__p_wxDropFilesEvent,
37937 &_swigt__p_wxDuplexMode,
37938 &_swigt__p_wxEraseEvent,
37939 &_swigt__p_wxEvent,
37940 &_swigt__p_wxEvtHandler,
37941 &_swigt__p_wxFSFile,
37942 &_swigt__p_wxFileConfig,
37943 &_swigt__p_wxFileDataObject,
37944 &_swigt__p_wxFileHistory,
37945 &_swigt__p_wxFileSystem,
37946 &_swigt__p_wxFileType,
37947 &_swigt__p_wxFileTypeInfo,
37948 &_swigt__p_wxFlexGridSizer,
37949 &_swigt__p_wxFocusEvent,
37950 &_swigt__p_wxFont,
37951 &_swigt__p_wxFrame,
37952 &_swigt__p_wxGBSizerItem,
37953 &_swigt__p_wxGIFHandler,
37954 &_swigt__p_wxGridBagSizer,
37955 &_swigt__p_wxGridSizer,
37956 &_swigt__p_wxICOHandler,
37957 &_swigt__p_wxIcon,
37958 &_swigt__p_wxIconizeEvent,
37959 &_swigt__p_wxIdleEvent,
37960 &_swigt__p_wxImage,
37961 &_swigt__p_wxImageHandler,
37962 &_swigt__p_wxIndividualLayoutConstraint,
37963 &_swigt__p_wxInitDialogEvent,
37964 &_swigt__p_wxJPEGHandler,
37965 &_swigt__p_wxJoystick,
37966 &_swigt__p_wxJoystickEvent,
37967 &_swigt__p_wxKeyEvent,
37968 &_swigt__p_wxKillError,
37969 &_swigt__p_wxLayoutConstraints,
37970 &_swigt__p_wxLog,
37971 &_swigt__p_wxLogBuffer,
37972 &_swigt__p_wxLogChain,
37973 &_swigt__p_wxLogGui,
37974 &_swigt__p_wxLogNull,
37975 &_swigt__p_wxLogStderr,
37976 &_swigt__p_wxLogTextCtrl,
37977 &_swigt__p_wxLogWindow,
37978 &_swigt__p_wxMaximizeEvent,
37979 &_swigt__p_wxMenu,
37980 &_swigt__p_wxMenuBar,
37981 &_swigt__p_wxMenuEvent,
37982 &_swigt__p_wxMenuItem,
37983 &_swigt__p_wxMetafileDataObject,
37984 &_swigt__p_wxMimeTypesManager,
37985 &_swigt__p_wxMouseCaptureChangedEvent,
37986 &_swigt__p_wxMouseEvent,
37987 &_swigt__p_wxMouseState,
37988 &_swigt__p_wxMoveEvent,
37989 &_swigt__p_wxMutexGuiLocker,
37990 &_swigt__p_wxNavigationKeyEvent,
37991 &_swigt__p_wxNcPaintEvent,
37992 &_swigt__p_wxNotifyEvent,
37993 &_swigt__p_wxObject,
37994 &_swigt__p_wxOutputStream,
37995 &_swigt__p_wxPCXHandler,
37996 &_swigt__p_wxPNGHandler,
37997 &_swigt__p_wxPNMHandler,
37998 &_swigt__p_wxPaintEvent,
37999 &_swigt__p_wxPaletteChangedEvent,
38000 &_swigt__p_wxPaperSize,
38001 &_swigt__p_wxPoint,
38002 &_swigt__p_wxPowerEvent,
38003 &_swigt__p_wxProcessEvent,
38004 &_swigt__p_wxPyApp,
38005 &_swigt__p_wxPyArtProvider,
38006 &_swigt__p_wxPyBitmapDataObject,
38007 &_swigt__p_wxPyCommandEvent,
38008 &_swigt__p_wxPyDataObjectSimple,
38009 &_swigt__p_wxPyDropSource,
38010 &_swigt__p_wxPyDropTarget,
38011 &_swigt__p_wxPyEvent,
38012 &_swigt__p_wxPyFileDropTarget,
38013 &_swigt__p_wxPyImageHandler,
38014 &_swigt__p_wxPyLog,
38015 &_swigt__p_wxPyProcess,
38016 &_swigt__p_wxPySizer,
38017 &_swigt__p_wxPyTextDataObject,
38018 &_swigt__p_wxPyTextDropTarget,
38019 &_swigt__p_wxPyTimer,
38020 &_swigt__p_wxPyTipProvider,
38021 &_swigt__p_wxPyValidator,
38022 &_swigt__p_wxQueryNewPaletteEvent,
38023 &_swigt__p_wxRect,
38024 &_swigt__p_wxScrollEvent,
38025 &_swigt__p_wxScrollWinEvent,
38026 &_swigt__p_wxSetCursorEvent,
38027 &_swigt__p_wxShowEvent,
38028 &_swigt__p_wxSingleInstanceChecker,
38029 &_swigt__p_wxSize,
38030 &_swigt__p_wxSizeEvent,
38031 &_swigt__p_wxSizer,
38032 &_swigt__p_wxSizerItem,
38033 &_swigt__p_wxSound,
38034 &_swigt__p_wxStandardPaths,
38035 &_swigt__p_wxStaticBoxSizer,
38036 &_swigt__p_wxStdDialogButtonSizer,
38037 &_swigt__p_wxStopWatch,
38038 &_swigt__p_wxString,
38039 &_swigt__p_wxSysColourChangedEvent,
38040 &_swigt__p_wxSystemOptions,
38041 &_swigt__p_wxSystemSettings,
38042 &_swigt__p_wxTIFFHandler,
38043 &_swigt__p_wxTextCtrl,
38044 &_swigt__p_wxTextDataObject,
38045 &_swigt__p_wxTimeSpan,
38046 &_swigt__p_wxTimer,
38047 &_swigt__p_wxTimerEvent,
38048 &_swigt__p_wxTimerRunner,
38049 &_swigt__p_wxTipProvider,
38050 &_swigt__p_wxToolTip,
38051 &_swigt__p_wxURLDataObject,
38052 &_swigt__p_wxUpdateUIEvent,
38053 &_swigt__p_wxValidator,
38054 &_swigt__p_wxVideoMode,
38055 &_swigt__p_wxWindow,
38056 &_swigt__p_wxWindowCreateEvent,
38057 &_swigt__p_wxWindowDestroyEvent,
38058 &_swigt__p_wxWindowDisabler,
38059 &_swigt__p_wxXPMHandler,
38060 };
38061
38062 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
38063 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
38064 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
38065 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
38066 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
38067 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
38068 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
38069 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
38070 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
38071 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}};
38072 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
38073 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
38074 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
38075 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
38076 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
38077 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
38078 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
38079 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
38080 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}};
38081 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
38082 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
38083 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
38084 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
38085 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
38086 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}};
38087 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
38088 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}};
38089 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
38090 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
38091 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
38092 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
38093 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
38094 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38095 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38096 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
38097 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
38098 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
38099 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
38100 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
38101 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
38102 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
38103 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
38104 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
38105 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
38106 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
38107 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38108 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38109 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
38110 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38111 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
38112 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
38113 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38114 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38115 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38116 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38117 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38118 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38119 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38120 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38121 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38122 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38123 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38124 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38125 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38126 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38127 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38128 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38129 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38130 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38131 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_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
38132 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38133 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38134 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38135 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38136 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38137 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38138 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}};
38139 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38140 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38141 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38142 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38143 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38144 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38145 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38146 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38147 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38148 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38149 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38150 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}};
38151 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38152 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38153 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38154 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38155 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38156 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38157 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38158 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38159 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38160 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38161 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38162 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38163 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38164 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38165 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38166 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38167 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38168 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38169 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38170 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38171 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38172 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38173 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38174 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38175 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38176 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38177 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38178 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38179 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38180 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38181 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38182 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38183 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38184 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38185 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38186 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38187 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38188 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38189 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38190 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38191 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38192 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38193 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
38194 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38195 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38196 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38197 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38198 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38199 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38200 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38201 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38202 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38203 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}};
38204 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38205 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38206 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38207 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38208 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38209 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38210 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38211 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38212 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38213 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38214 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38215 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38216 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38217 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38218 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38219 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38220 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38221 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}};
38222 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38223 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38224 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38225 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38226 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}};
38227 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38228 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38229 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38230 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}};
38231 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38232
38233 static swig_cast_info *swig_cast_initial[] = {
38234 _swigc__p_char,
38235 _swigc__p_form_ops_t,
38236 _swigc__p_int,
38237 _swigc__p_unsigned_char,
38238 _swigc__p_unsigned_int,
38239 _swigc__p_unsigned_long,
38240 _swigc__p_void,
38241 _swigc__p_wxANIHandler,
38242 _swigc__p_wxAcceleratorTable,
38243 _swigc__p_wxActivateEvent,
38244 _swigc__p_wxArrayString,
38245 _swigc__p_wxBMPHandler,
38246 _swigc__p_wxBitmap,
38247 _swigc__p_wxBitmapDataObject,
38248 _swigc__p_wxBoxSizer,
38249 _swigc__p_wxBusyCursor,
38250 _swigc__p_wxBusyInfo,
38251 _swigc__p_wxCURHandler,
38252 _swigc__p_wxCaret,
38253 _swigc__p_wxChar,
38254 _swigc__p_wxChildFocusEvent,
38255 _swigc__p_wxClipboard,
38256 _swigc__p_wxClipboardLocker,
38257 _swigc__p_wxClipboardTextEvent,
38258 _swigc__p_wxCloseEvent,
38259 _swigc__p_wxColour,
38260 _swigc__p_wxCommandEvent,
38261 _swigc__p_wxConfig,
38262 _swigc__p_wxConfigBase,
38263 _swigc__p_wxConfigPathChanger,
38264 _swigc__p_wxContextMenuEvent,
38265 _swigc__p_wxControl,
38266 _swigc__p_wxControlWithItems,
38267 _swigc__p_wxCursor,
38268 _swigc__p_wxCustomDataObject,
38269 _swigc__p_wxDC,
38270 _swigc__p_wxDataFormat,
38271 _swigc__p_wxDataObject,
38272 _swigc__p_wxDataObjectComposite,
38273 _swigc__p_wxDataObjectSimple,
38274 _swigc__p_wxDateEvent,
38275 _swigc__p_wxDateSpan,
38276 _swigc__p_wxDateTime,
38277 _swigc__p_wxDateTime__TimeZone,
38278 _swigc__p_wxDisplay,
38279 _swigc__p_wxDisplayChangedEvent,
38280 _swigc__p_wxDropFilesEvent,
38281 _swigc__p_wxDuplexMode,
38282 _swigc__p_wxEraseEvent,
38283 _swigc__p_wxEvent,
38284 _swigc__p_wxEvtHandler,
38285 _swigc__p_wxFSFile,
38286 _swigc__p_wxFileConfig,
38287 _swigc__p_wxFileDataObject,
38288 _swigc__p_wxFileHistory,
38289 _swigc__p_wxFileSystem,
38290 _swigc__p_wxFileType,
38291 _swigc__p_wxFileTypeInfo,
38292 _swigc__p_wxFlexGridSizer,
38293 _swigc__p_wxFocusEvent,
38294 _swigc__p_wxFont,
38295 _swigc__p_wxFrame,
38296 _swigc__p_wxGBSizerItem,
38297 _swigc__p_wxGIFHandler,
38298 _swigc__p_wxGridBagSizer,
38299 _swigc__p_wxGridSizer,
38300 _swigc__p_wxICOHandler,
38301 _swigc__p_wxIcon,
38302 _swigc__p_wxIconizeEvent,
38303 _swigc__p_wxIdleEvent,
38304 _swigc__p_wxImage,
38305 _swigc__p_wxImageHandler,
38306 _swigc__p_wxIndividualLayoutConstraint,
38307 _swigc__p_wxInitDialogEvent,
38308 _swigc__p_wxJPEGHandler,
38309 _swigc__p_wxJoystick,
38310 _swigc__p_wxJoystickEvent,
38311 _swigc__p_wxKeyEvent,
38312 _swigc__p_wxKillError,
38313 _swigc__p_wxLayoutConstraints,
38314 _swigc__p_wxLog,
38315 _swigc__p_wxLogBuffer,
38316 _swigc__p_wxLogChain,
38317 _swigc__p_wxLogGui,
38318 _swigc__p_wxLogNull,
38319 _swigc__p_wxLogStderr,
38320 _swigc__p_wxLogTextCtrl,
38321 _swigc__p_wxLogWindow,
38322 _swigc__p_wxMaximizeEvent,
38323 _swigc__p_wxMenu,
38324 _swigc__p_wxMenuBar,
38325 _swigc__p_wxMenuEvent,
38326 _swigc__p_wxMenuItem,
38327 _swigc__p_wxMetafileDataObject,
38328 _swigc__p_wxMimeTypesManager,
38329 _swigc__p_wxMouseCaptureChangedEvent,
38330 _swigc__p_wxMouseEvent,
38331 _swigc__p_wxMouseState,
38332 _swigc__p_wxMoveEvent,
38333 _swigc__p_wxMutexGuiLocker,
38334 _swigc__p_wxNavigationKeyEvent,
38335 _swigc__p_wxNcPaintEvent,
38336 _swigc__p_wxNotifyEvent,
38337 _swigc__p_wxObject,
38338 _swigc__p_wxOutputStream,
38339 _swigc__p_wxPCXHandler,
38340 _swigc__p_wxPNGHandler,
38341 _swigc__p_wxPNMHandler,
38342 _swigc__p_wxPaintEvent,
38343 _swigc__p_wxPaletteChangedEvent,
38344 _swigc__p_wxPaperSize,
38345 _swigc__p_wxPoint,
38346 _swigc__p_wxPowerEvent,
38347 _swigc__p_wxProcessEvent,
38348 _swigc__p_wxPyApp,
38349 _swigc__p_wxPyArtProvider,
38350 _swigc__p_wxPyBitmapDataObject,
38351 _swigc__p_wxPyCommandEvent,
38352 _swigc__p_wxPyDataObjectSimple,
38353 _swigc__p_wxPyDropSource,
38354 _swigc__p_wxPyDropTarget,
38355 _swigc__p_wxPyEvent,
38356 _swigc__p_wxPyFileDropTarget,
38357 _swigc__p_wxPyImageHandler,
38358 _swigc__p_wxPyLog,
38359 _swigc__p_wxPyProcess,
38360 _swigc__p_wxPySizer,
38361 _swigc__p_wxPyTextDataObject,
38362 _swigc__p_wxPyTextDropTarget,
38363 _swigc__p_wxPyTimer,
38364 _swigc__p_wxPyTipProvider,
38365 _swigc__p_wxPyValidator,
38366 _swigc__p_wxQueryNewPaletteEvent,
38367 _swigc__p_wxRect,
38368 _swigc__p_wxScrollEvent,
38369 _swigc__p_wxScrollWinEvent,
38370 _swigc__p_wxSetCursorEvent,
38371 _swigc__p_wxShowEvent,
38372 _swigc__p_wxSingleInstanceChecker,
38373 _swigc__p_wxSize,
38374 _swigc__p_wxSizeEvent,
38375 _swigc__p_wxSizer,
38376 _swigc__p_wxSizerItem,
38377 _swigc__p_wxSound,
38378 _swigc__p_wxStandardPaths,
38379 _swigc__p_wxStaticBoxSizer,
38380 _swigc__p_wxStdDialogButtonSizer,
38381 _swigc__p_wxStopWatch,
38382 _swigc__p_wxString,
38383 _swigc__p_wxSysColourChangedEvent,
38384 _swigc__p_wxSystemOptions,
38385 _swigc__p_wxSystemSettings,
38386 _swigc__p_wxTIFFHandler,
38387 _swigc__p_wxTextCtrl,
38388 _swigc__p_wxTextDataObject,
38389 _swigc__p_wxTimeSpan,
38390 _swigc__p_wxTimer,
38391 _swigc__p_wxTimerEvent,
38392 _swigc__p_wxTimerRunner,
38393 _swigc__p_wxTipProvider,
38394 _swigc__p_wxToolTip,
38395 _swigc__p_wxURLDataObject,
38396 _swigc__p_wxUpdateUIEvent,
38397 _swigc__p_wxValidator,
38398 _swigc__p_wxVideoMode,
38399 _swigc__p_wxWindow,
38400 _swigc__p_wxWindowCreateEvent,
38401 _swigc__p_wxWindowDestroyEvent,
38402 _swigc__p_wxWindowDisabler,
38403 _swigc__p_wxXPMHandler,
38404 };
38405
38406
38407 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38408
38409 static swig_const_info swig_const_table[] = {
38410 {0, 0, 0, 0.0, 0, 0}};
38411
38412 #ifdef __cplusplus
38413 }
38414 #endif
38415 /* -----------------------------------------------------------------------------
38416 * Type initialization:
38417 * This problem is tough by the requirement that no dynamic
38418 * memory is used. Also, since swig_type_info structures store pointers to
38419 * swig_cast_info structures and swig_cast_info structures store pointers back
38420 * to swig_type_info structures, we need some lookup code at initialization.
38421 * The idea is that swig generates all the structures that are needed.
38422 * The runtime then collects these partially filled structures.
38423 * The SWIG_InitializeModule function takes these initial arrays out of
38424 * swig_module, and does all the lookup, filling in the swig_module.types
38425 * array with the correct data and linking the correct swig_cast_info
38426 * structures together.
38427 *
38428 * The generated swig_type_info structures are assigned staticly to an initial
38429 * array. We just loop though that array, and handle each type individually.
38430 * First we lookup if this type has been already loaded, and if so, use the
38431 * loaded structure instead of the generated one. Then we have to fill in the
38432 * cast linked list. The cast data is initially stored in something like a
38433 * two-dimensional array. Each row corresponds to a type (there are the same
38434 * number of rows as there are in the swig_type_initial array). Each entry in
38435 * a column is one of the swig_cast_info structures for that type.
38436 * The cast_initial array is actually an array of arrays, because each row has
38437 * a variable number of columns. So to actually build the cast linked list,
38438 * we find the array of casts associated with the type, and loop through it
38439 * adding the casts to the list. The one last trick we need to do is making
38440 * sure the type pointer in the swig_cast_info struct is correct.
38441 *
38442 * First off, we lookup the cast->type name to see if it is already loaded.
38443 * There are three cases to handle:
38444 * 1) If the cast->type has already been loaded AND the type we are adding
38445 * casting info to has not been loaded (it is in this module), THEN we
38446 * replace the cast->type pointer with the type pointer that has already
38447 * been loaded.
38448 * 2) If BOTH types (the one we are adding casting info to, and the
38449 * cast->type) are loaded, THEN the cast info has already been loaded by
38450 * the previous module so we just ignore it.
38451 * 3) Finally, if cast->type has not already been loaded, then we add that
38452 * swig_cast_info to the linked list (because the cast->type) pointer will
38453 * be correct.
38454 * ----------------------------------------------------------------------------- */
38455
38456 #ifdef __cplusplus
38457 extern "C" {
38458 #if 0
38459 } /* c-mode */
38460 #endif
38461 #endif
38462
38463 #if 0
38464 #define SWIGRUNTIME_DEBUG
38465 #endif
38466
38467 SWIGRUNTIME void
38468 SWIG_InitializeModule(void *clientdata) {
38469 size_t i;
38470 swig_module_info *module_head;
38471 static int init_run = 0;
38472
38473 clientdata = clientdata;
38474
38475 if (init_run) return;
38476 init_run = 1;
38477
38478 /* Initialize the swig_module */
38479 swig_module.type_initial = swig_type_initial;
38480 swig_module.cast_initial = swig_cast_initial;
38481
38482 /* Try and load any already created modules */
38483 module_head = SWIG_GetModule(clientdata);
38484 if (module_head) {
38485 swig_module.next = module_head->next;
38486 module_head->next = &swig_module;
38487 } else {
38488 /* This is the first module loaded */
38489 swig_module.next = &swig_module;
38490 SWIG_SetModule(clientdata, &swig_module);
38491 }
38492
38493 /* Now work on filling in swig_module.types */
38494 #ifdef SWIGRUNTIME_DEBUG
38495 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38496 #endif
38497 for (i = 0; i < swig_module.size; ++i) {
38498 swig_type_info *type = 0;
38499 swig_type_info *ret;
38500 swig_cast_info *cast;
38501
38502 #ifdef SWIGRUNTIME_DEBUG
38503 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38504 #endif
38505
38506 /* if there is another module already loaded */
38507 if (swig_module.next != &swig_module) {
38508 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38509 }
38510 if (type) {
38511 /* Overwrite clientdata field */
38512 #ifdef SWIGRUNTIME_DEBUG
38513 printf("SWIG_InitializeModule: found type %s\n", type->name);
38514 #endif
38515 if (swig_module.type_initial[i]->clientdata) {
38516 type->clientdata = swig_module.type_initial[i]->clientdata;
38517 #ifdef SWIGRUNTIME_DEBUG
38518 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38519 #endif
38520 }
38521 } else {
38522 type = swig_module.type_initial[i];
38523 }
38524
38525 /* Insert casting types */
38526 cast = swig_module.cast_initial[i];
38527 while (cast->type) {
38528 /* Don't need to add information already in the list */
38529 ret = 0;
38530 #ifdef SWIGRUNTIME_DEBUG
38531 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38532 #endif
38533 if (swig_module.next != &swig_module) {
38534 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38535 #ifdef SWIGRUNTIME_DEBUG
38536 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38537 #endif
38538 }
38539 if (ret) {
38540 if (type == swig_module.type_initial[i]) {
38541 #ifdef SWIGRUNTIME_DEBUG
38542 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38543 #endif
38544 cast->type = ret;
38545 ret = 0;
38546 } else {
38547 /* Check for casting already in the list */
38548 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38549 #ifdef SWIGRUNTIME_DEBUG
38550 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38551 #endif
38552 if (!ocast) ret = 0;
38553 }
38554 }
38555
38556 if (!ret) {
38557 #ifdef SWIGRUNTIME_DEBUG
38558 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38559 #endif
38560 if (type->cast) {
38561 type->cast->prev = cast;
38562 cast->next = type->cast;
38563 }
38564 type->cast = cast;
38565 }
38566 cast++;
38567 }
38568 /* Set entry in modules->types array equal to the type */
38569 swig_module.types[i] = type;
38570 }
38571 swig_module.types[i] = 0;
38572
38573 #ifdef SWIGRUNTIME_DEBUG
38574 printf("**** SWIG_InitializeModule: Cast List ******\n");
38575 for (i = 0; i < swig_module.size; ++i) {
38576 int j = 0;
38577 swig_cast_info *cast = swig_module.cast_initial[i];
38578 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38579 while (cast->type) {
38580 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38581 cast++;
38582 ++j;
38583 }
38584 printf("---- Total casts: %d\n",j);
38585 }
38586 printf("**** SWIG_InitializeModule: Cast List ******\n");
38587 #endif
38588 }
38589
38590 /* This function will propagate the clientdata field of type to
38591 * any new swig_type_info structures that have been added into the list
38592 * of equivalent types. It is like calling
38593 * SWIG_TypeClientData(type, clientdata) a second time.
38594 */
38595 SWIGRUNTIME void
38596 SWIG_PropagateClientData(void) {
38597 size_t i;
38598 swig_cast_info *equiv;
38599 static int init_run = 0;
38600
38601 if (init_run) return;
38602 init_run = 1;
38603
38604 for (i = 0; i < swig_module.size; i++) {
38605 if (swig_module.types[i]->clientdata) {
38606 equiv = swig_module.types[i]->cast;
38607 while (equiv) {
38608 if (!equiv->converter) {
38609 if (equiv->type && !equiv->type->clientdata)
38610 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38611 }
38612 equiv = equiv->next;
38613 }
38614 }
38615 }
38616 }
38617
38618 #ifdef __cplusplus
38619 #if 0
38620 {
38621 /* c-mode */
38622 #endif
38623 }
38624 #endif
38625
38626
38627
38628 #ifdef __cplusplus
38629 extern "C" {
38630 #endif
38631
38632 /* Python-specific SWIG API */
38633 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38634 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38635 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38636
38637 /* -----------------------------------------------------------------------------
38638 * global variable support code.
38639 * ----------------------------------------------------------------------------- */
38640
38641 typedef struct swig_globalvar {
38642 char *name; /* Name of global variable */
38643 PyObject *(*get_attr)(void); /* Return the current value */
38644 int (*set_attr)(PyObject *); /* Set the value */
38645 struct swig_globalvar *next;
38646 } swig_globalvar;
38647
38648 typedef struct swig_varlinkobject {
38649 PyObject_HEAD
38650 swig_globalvar *vars;
38651 } swig_varlinkobject;
38652
38653 SWIGINTERN PyObject *
38654 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38655 return PyString_FromString("<Swig global variables>");
38656 }
38657
38658 SWIGINTERN PyObject *
38659 swig_varlink_str(swig_varlinkobject *v) {
38660 PyObject *str = PyString_FromString("(");
38661 swig_globalvar *var;
38662 for (var = v->vars; var; var=var->next) {
38663 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38664 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38665 }
38666 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38667 return str;
38668 }
38669
38670 SWIGINTERN int
38671 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38672 PyObject *str = swig_varlink_str(v);
38673 fprintf(fp,"Swig global variables ");
38674 fprintf(fp,"%s\n", PyString_AsString(str));
38675 Py_DECREF(str);
38676 return 0;
38677 }
38678
38679 SWIGINTERN void
38680 swig_varlink_dealloc(swig_varlinkobject *v) {
38681 swig_globalvar *var = v->vars;
38682 while (var) {
38683 swig_globalvar *n = var->next;
38684 free(var->name);
38685 free(var);
38686 var = n;
38687 }
38688 }
38689
38690 SWIGINTERN PyObject *
38691 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38692 PyObject *res = NULL;
38693 swig_globalvar *var = v->vars;
38694 while (var) {
38695 if (strcmp(var->name,n) == 0) {
38696 res = (*var->get_attr)();
38697 break;
38698 }
38699 var = var->next;
38700 }
38701 if (res == NULL && !PyErr_Occurred()) {
38702 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38703 }
38704 return res;
38705 }
38706
38707 SWIGINTERN int
38708 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38709 int res = 1;
38710 swig_globalvar *var = v->vars;
38711 while (var) {
38712 if (strcmp(var->name,n) == 0) {
38713 res = (*var->set_attr)(p);
38714 break;
38715 }
38716 var = var->next;
38717 }
38718 if (res == 1 && !PyErr_Occurred()) {
38719 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38720 }
38721 return res;
38722 }
38723
38724 SWIGINTERN PyTypeObject*
38725 swig_varlink_type(void) {
38726 static char varlink__doc__[] = "Swig var link object";
38727 static PyTypeObject varlink_type;
38728 static int type_init = 0;
38729 if (!type_init) {
38730 const PyTypeObject tmp
38731 = {
38732 PyObject_HEAD_INIT(NULL)
38733 0, /* Number of items in variable part (ob_size) */
38734 (char *)"swigvarlink", /* Type name (tp_name) */
38735 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38736 0, /* Itemsize (tp_itemsize) */
38737 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38738 (printfunc) swig_varlink_print, /* Print (tp_print) */
38739 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38740 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38741 0, /* tp_compare */
38742 (reprfunc) swig_varlink_repr, /* tp_repr */
38743 0, /* tp_as_number */
38744 0, /* tp_as_sequence */
38745 0, /* tp_as_mapping */
38746 0, /* tp_hash */
38747 0, /* tp_call */
38748 (reprfunc)swig_varlink_str, /* tp_str */
38749 0, /* tp_getattro */
38750 0, /* tp_setattro */
38751 0, /* tp_as_buffer */
38752 0, /* tp_flags */
38753 varlink__doc__, /* tp_doc */
38754 0, /* tp_traverse */
38755 0, /* tp_clear */
38756 0, /* tp_richcompare */
38757 0, /* tp_weaklistoffset */
38758 #if PY_VERSION_HEX >= 0x02020000
38759 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38760 #endif
38761 #if PY_VERSION_HEX >= 0x02030000
38762 0, /* tp_del */
38763 #endif
38764 #ifdef COUNT_ALLOCS
38765 0,0,0,0 /* tp_alloc -> tp_next */
38766 #endif
38767 };
38768 varlink_type = tmp;
38769 varlink_type.ob_type = &PyType_Type;
38770 type_init = 1;
38771 }
38772 return &varlink_type;
38773 }
38774
38775 /* Create a variable linking object for use later */
38776 SWIGINTERN PyObject *
38777 SWIG_Python_newvarlink(void) {
38778 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38779 if (result) {
38780 result->vars = 0;
38781 }
38782 return ((PyObject*) result);
38783 }
38784
38785 SWIGINTERN void
38786 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38787 swig_varlinkobject *v = (swig_varlinkobject *) p;
38788 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38789 if (gv) {
38790 size_t size = strlen(name)+1;
38791 gv->name = (char *)malloc(size);
38792 if (gv->name) {
38793 strncpy(gv->name,name,size);
38794 gv->get_attr = get_attr;
38795 gv->set_attr = set_attr;
38796 gv->next = v->vars;
38797 }
38798 }
38799 v->vars = gv;
38800 }
38801
38802 SWIGINTERN PyObject *
38803 SWIG_globals() {
38804 static PyObject *_SWIG_globals = 0;
38805 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38806 return _SWIG_globals;
38807 }
38808
38809 /* -----------------------------------------------------------------------------
38810 * constants/methods manipulation
38811 * ----------------------------------------------------------------------------- */
38812
38813 /* Install Constants */
38814 SWIGINTERN void
38815 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38816 PyObject *obj = 0;
38817 size_t i;
38818 for (i = 0; constants[i].type; ++i) {
38819 switch(constants[i].type) {
38820 case SWIG_PY_POINTER:
38821 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38822 break;
38823 case SWIG_PY_BINARY:
38824 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38825 break;
38826 default:
38827 obj = 0;
38828 break;
38829 }
38830 if (obj) {
38831 PyDict_SetItemString(d, constants[i].name, obj);
38832 Py_DECREF(obj);
38833 }
38834 }
38835 }
38836
38837 /* -----------------------------------------------------------------------------*/
38838 /* Fix SwigMethods to carry the callback ptrs when needed */
38839 /* -----------------------------------------------------------------------------*/
38840
38841 SWIGINTERN void
38842 SWIG_Python_FixMethods(PyMethodDef *methods,
38843 swig_const_info *const_table,
38844 swig_type_info **types,
38845 swig_type_info **types_initial) {
38846 size_t i;
38847 for (i = 0; methods[i].ml_name; ++i) {
38848 const char *c = methods[i].ml_doc;
38849 if (c && (c = strstr(c, "swig_ptr: "))) {
38850 int j;
38851 swig_const_info *ci = 0;
38852 const char *name = c + 10;
38853 for (j = 0; const_table[j].type; ++j) {
38854 if (strncmp(const_table[j].name, name,
38855 strlen(const_table[j].name)) == 0) {
38856 ci = &(const_table[j]);
38857 break;
38858 }
38859 }
38860 if (ci) {
38861 size_t shift = (ci->ptype) - types;
38862 swig_type_info *ty = types_initial[shift];
38863 size_t ldoc = (c - methods[i].ml_doc);
38864 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38865 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38866 if (ndoc) {
38867 char *buff = ndoc;
38868 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38869 if (ptr) {
38870 strncpy(buff, methods[i].ml_doc, ldoc);
38871 buff += ldoc;
38872 strncpy(buff, "swig_ptr: ", 10);
38873 buff += 10;
38874 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38875 methods[i].ml_doc = ndoc;
38876 }
38877 }
38878 }
38879 }
38880 }
38881 }
38882
38883 #ifdef __cplusplus
38884 }
38885 #endif
38886
38887 /* -----------------------------------------------------------------------------*
38888 * Partial Init method
38889 * -----------------------------------------------------------------------------*/
38890
38891 #ifdef __cplusplus
38892 extern "C"
38893 #endif
38894 SWIGEXPORT void SWIG_init(void) {
38895 PyObject *m, *d;
38896
38897 /* Fix SwigMethods to carry the callback ptrs when needed */
38898 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38899
38900 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38901 d = PyModule_GetDict(m);
38902
38903 SWIG_InitializeModule(0);
38904 SWIG_InstallConstants(d,swig_const_table);
38905
38906
38907 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38908 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38909 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38910 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38911 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38912 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38913 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38914 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38915 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38916 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38917 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38918 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38919 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38920 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38921 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38922 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38923 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38924 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38925 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38926 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38927 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38928 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38929 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38930 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38931 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38932 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38933 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38934 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38935 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38936 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38937 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38938 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38939 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38940 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38941 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38942 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38943 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38944 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38945 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38946 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38947 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38948 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38949 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38950 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38951 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38952 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38953 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38954 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38955 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38956 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38957 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38958 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38959 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38960 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38961 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38962 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38963 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38964 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38965 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38966 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38967 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38968 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38969 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38970 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38971 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38972 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38973 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38974 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38975 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38976 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38977 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38978 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38979 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38980 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38981 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38982 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38983 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38984 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38985 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38986 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38987 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38988 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38989 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38990 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38991 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38992 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38993 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38994 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38995 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38996 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38997 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38998 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38999 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
39000 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
39001 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
39002 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
39003 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
39004 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
39005 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
39006 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
39007 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
39008 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
39009 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
39010 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
39011 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
39012 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
39013 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
39014 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
39015 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
39016 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
39017 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
39018 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
39019 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
39020 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
39021 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
39022 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
39023 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
39024 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
39025 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
39026 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
39027 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
39028 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
39029 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
39030 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
39031 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
39032 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
39033 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
39034 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
39035 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
39036 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
39037 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
39038 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
39039 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
39040 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
39041 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
39042 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
39043 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
39044
39045 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
39046
39047 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
39048 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
39049 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
39050 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
39051 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
39052 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
39053 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
39054 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
39055 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
39056 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
39057 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
39058 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
39059 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
39060 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
39061 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
39062 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
39063 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
39064 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
39065 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
39066 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
39067 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
39068 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
39069 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
39070 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
39071 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
39072 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
39073 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
39074 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
39075 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
39076 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
39077 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
39078 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
39079 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
39080 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
39081 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
39082 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
39083 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
39084 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
39085 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
39086 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
39087 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
39088 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
39089 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
39090 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
39091 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
39092 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
39093 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
39094 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
39095 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
39096 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
39097 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
39098 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
39099 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
39100
39101 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
39102
39103 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
39104 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
39105 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
39106 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
39107 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
39108 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
39109 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
39110 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
39111 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
39112 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
39113 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
39114 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
39115 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
39116 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
39117 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
39118 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
39119 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
39120 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
39121 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
39122 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
39123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
39124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
39125 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
39126 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
39127 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
39128 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
39129 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
39130 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
39131 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
39132 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
39133 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
39134 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
39135 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
39136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
39137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39179
39180 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39181
39182 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39183 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39184 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39185 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39186 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39187 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39188 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39189 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39190 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39191 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39192 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39193 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39194 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39195 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39196 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39197 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39198 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39199 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39200 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39201 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39202 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39203 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39204 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39205 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39206 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39207 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39208 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39209 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39210 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39211 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39212 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39213 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39214 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39215 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39216 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39217 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39218 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39219 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39220 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39221 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39222 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39223 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39224 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39225 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39226 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39227 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39228 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39229 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39230 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39231 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39232 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39233 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39234 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39235 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39236 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39237 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39238 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39239 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39240 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39241 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39242 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39243 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39244 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39245 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39246 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39247 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39248 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39249 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39250 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39251 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39252 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39253 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39254 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39255 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39256 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39257 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39258 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39259 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39260 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39261 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39262 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39263 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39264 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39265 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39266 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39267 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39268 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39269 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39270 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39271 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39272 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39273 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39274 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39275 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39276 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39277 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39278 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39279 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39280 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39281 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39282 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39283 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39284 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39285 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39286 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39287 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39288 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39289 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39290 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39291 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39292 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39293 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39294 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39295 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39296 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39297 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39298 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39299 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39300 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39301 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39302 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39303 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39304 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39305 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39306 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39307 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39308 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39309 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39310 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39311 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39312 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39313 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39314 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39315 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39316 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39317 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39318 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39319 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39320 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39321 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39322 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39323 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39324 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39325 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39326 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39327 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39328 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39329 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39330 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39331 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39332 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39333 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39334 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39335 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39336 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39337 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39338 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39339 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39340 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39341 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39342 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39343 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39344 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39345 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39346 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39347 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39348 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39349 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39350 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39351 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39352 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39353 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39354 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39355 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39356 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39357 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39358 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39359 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39360 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39361 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39362 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39363 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39364 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39365 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39366 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39367 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39368 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39369 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39370 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39371 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39372 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39373 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39374 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39375 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39376 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39377 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39378 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39379 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39380 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39381 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39382
39383 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39384 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39385 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39386 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39387
39388 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39389 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39390 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39391 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39392 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39393 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39394 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39395 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39396 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39397 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39398 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39399 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39400 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39401 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39402 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39403 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39404 }
39405
wxWidgets (Impactor)