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


13e9c7ca5df9e8f4921bab97d3c8ed7c115c4185
[wxWidgets.git] / wxPython / src / msw / _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_wxMemorySize swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPoint swig_types[113]
2580 #define SWIGTYPE_p_wxPowerEvent swig_types[114]
2581 #define SWIGTYPE_p_wxProcessEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPyApp swig_types[116]
2583 #define SWIGTYPE_p_wxPyArtProvider swig_types[117]
2584 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[118]
2585 #define SWIGTYPE_p_wxPyCommandEvent swig_types[119]
2586 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropSource swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
2589 #define SWIGTYPE_p_wxPyEvent swig_types[123]
2590 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyImageHandler swig_types[125]
2592 #define SWIGTYPE_p_wxPyLog swig_types[126]
2593 #define SWIGTYPE_p_wxPyProcess swig_types[127]
2594 #define SWIGTYPE_p_wxPySizer swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDataObject swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[130]
2597 #define SWIGTYPE_p_wxPyTimer swig_types[131]
2598 #define SWIGTYPE_p_wxPyTipProvider swig_types[132]
2599 #define SWIGTYPE_p_wxPyValidator swig_types[133]
2600 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[134]
2601 #define SWIGTYPE_p_wxRect swig_types[135]
2602 #define SWIGTYPE_p_wxScrollEvent swig_types[136]
2603 #define SWIGTYPE_p_wxScrollWinEvent swig_types[137]
2604 #define SWIGTYPE_p_wxSetCursorEvent swig_types[138]
2605 #define SWIGTYPE_p_wxShowEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[140]
2607 #define SWIGTYPE_p_wxSize swig_types[141]
2608 #define SWIGTYPE_p_wxSizeEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSizer swig_types[143]
2610 #define SWIGTYPE_p_wxSizerItem swig_types[144]
2611 #define SWIGTYPE_p_wxSound swig_types[145]
2612 #define SWIGTYPE_p_wxStandardPaths swig_types[146]
2613 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStopWatch swig_types[149]
2616 #define SWIGTYPE_p_wxString swig_types[150]
2617 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[151]
2618 #define SWIGTYPE_p_wxSystemOptions swig_types[152]
2619 #define SWIGTYPE_p_wxSystemSettings swig_types[153]
2620 #define SWIGTYPE_p_wxTIFFHandler swig_types[154]
2621 #define SWIGTYPE_p_wxTextCtrl swig_types[155]
2622 #define SWIGTYPE_p_wxTextDataObject swig_types[156]
2623 #define SWIGTYPE_p_wxTimeSpan swig_types[157]
2624 #define SWIGTYPE_p_wxTimer swig_types[158]
2625 #define SWIGTYPE_p_wxTimerEvent swig_types[159]
2626 #define SWIGTYPE_p_wxTimerRunner swig_types[160]
2627 #define SWIGTYPE_p_wxTipProvider swig_types[161]
2628 #define SWIGTYPE_p_wxToolTip swig_types[162]
2629 #define SWIGTYPE_p_wxURLDataObject swig_types[163]
2630 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[164]
2631 #define SWIGTYPE_p_wxValidator swig_types[165]
2632 #define SWIGTYPE_p_wxVideoMode swig_types[166]
2633 #define SWIGTYPE_p_wxWindow swig_types[167]
2634 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDisabler swig_types[170]
2637 #define SWIGTYPE_p_wxXPMHandler swig_types[171]
2638 static swig_type_info *swig_types[173];
2639 static swig_module_info swig_module = {swig_types, 172, 0, 0, 0, 0};
2640 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2641 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2642
2643 /* -------- TYPES TABLE (END) -------- */
2644
2645 #if (PY_VERSION_HEX <= 0x02000000)
2646 # if !defined(SWIG_PYTHON_CLASSIC)
2647 # error "This python version requires to use swig with the '-classic' option"
2648 # endif
2649 #endif
2650 #if (PY_VERSION_HEX <= 0x02020000)
2651 # error "This python version requires to use swig with the '-nomodern' option"
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodernargs' option"
2655 #endif
2656 #ifndef METH_O
2657 # error "This python version requires to use swig with the '-nofastunpack' option"
2658 #endif
2659
2660 /*-----------------------------------------------
2661 @(target):= _misc_.so
2662 ------------------------------------------------*/
2663 #define SWIG_init init_misc_
2664
2665 #define SWIG_name "_misc_"
2666
2667 #define SWIGVERSION 0x010329
2668
2669
2670 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2671 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2672
2673
2674 #include <stdexcept>
2675
2676
2677 namespace swig {
2678 class PyObject_ptr {
2679 protected:
2680 PyObject *_obj;
2681
2682 public:
2683 PyObject_ptr() :_obj(0)
2684 {
2685 }
2686
2687 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2688 {
2689 Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2693 {
2694 if (initial_ref) Py_XINCREF(_obj);
2695 }
2696
2697 PyObject_ptr & operator=(const PyObject_ptr& item)
2698 {
2699 Py_XINCREF(item._obj);
2700 Py_XDECREF(_obj);
2701 _obj = item._obj;
2702 return *this;
2703 }
2704
2705 ~PyObject_ptr()
2706 {
2707 Py_XDECREF(_obj);
2708 }
2709
2710 operator PyObject *() const
2711 {
2712 return _obj;
2713 }
2714
2715 PyObject *operator->() const
2716 {
2717 return _obj;
2718 }
2719 };
2720 }
2721
2722
2723 namespace swig {
2724 struct PyObject_var : PyObject_ptr {
2725 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2726
2727 PyObject_var & operator = (PyObject* obj)
2728 {
2729 Py_XDECREF(_obj);
2730 _obj = obj;
2731 return *this;
2732 }
2733 };
2734 }
2735
2736
2737 #include "wx/wxPython/wxPython.h"
2738 #include "wx/wxPython/pyclasses.h"
2739 #include "wx/wxPython/pyistream.h"
2740
2741 static const wxString wxPyEmptyString(wxEmptyString);
2742
2743
2744
2745 #define SWIG_From_long PyInt_FromLong
2746
2747
2748 SWIGINTERNINLINE PyObject *
2749 SWIG_From_int (int value)
2750 {
2751 return SWIG_From_long (value);
2752 }
2753
2754
2755 #include <limits.h>
2756 #ifndef LLONG_MIN
2757 # define LLONG_MIN LONG_LONG_MIN
2758 #endif
2759 #ifndef LLONG_MAX
2760 # define LLONG_MAX LONG_LONG_MAX
2761 #endif
2762 #ifndef ULLONG_MAX
2763 # define ULLONG_MAX ULONG_LONG_MAX
2764 #endif
2765
2766
2767 SWIGINTERN int
2768 SWIG_AsVal_long (PyObject* obj, long* val)
2769 {
2770 if (PyNumber_Check(obj)) {
2771 if (val) *val = PyInt_AsLong(obj);
2772 return SWIG_OK;
2773 }
2774 return SWIG_TypeError;
2775 }
2776
2777
2778 SWIGINTERN int
2779 SWIG_AsVal_int (PyObject * obj, int *val)
2780 {
2781 long v;
2782 int res = SWIG_AsVal_long (obj, &v);
2783 if (SWIG_IsOK(res)) {
2784 if ((v < INT_MIN || v > INT_MAX)) {
2785 return SWIG_OverflowError;
2786 } else {
2787 if (val) *val = static_cast< int >(v);
2788 }
2789 }
2790 return res;
2791 }
2792
2793 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2794
2795 #include <wx/stockitem.h>
2796
2797 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2798 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2799 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2800
2801 SWIGINTERN int
2802 SWIG_AsVal_bool (PyObject *obj, bool *val)
2803 {
2804 if (obj == Py_True) {
2805 if (val) *val = true;
2806 return SWIG_OK;
2807 } else if (obj == Py_False) {
2808 if (val) *val = false;
2809 return SWIG_OK;
2810 } else {
2811 long v = 0;
2812 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2813 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2814 return res;
2815 }
2816 }
2817
2818
2819 SWIGINTERN int
2820 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2821 {
2822 long v = 0;
2823 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2824 return SWIG_TypeError;
2825 }
2826 else if (val)
2827 *val = (unsigned long)v;
2828 return SWIG_OK;
2829 }
2830
2831
2832 SWIGINTERNINLINE PyObject*
2833 SWIG_From_unsigned_SS_long (unsigned long value)
2834 {
2835 return (value > LONG_MAX) ?
2836 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2837 }
2838
2839
2840 void* wxGetXDisplay()
2841 {
2842 #ifdef __WXGTK__
2843 return wxGetDisplay();
2844 #else
2845 return NULL;
2846 #endif
2847 }
2848
2849
2850 wxWindow* FindWindowAtPointer() {
2851 wxPoint unused;
2852 return wxFindWindowAtPointer(unused);
2853 }
2854
2855
2856 bool wxThread_IsMain() {
2857 #ifdef WXP_WITH_THREAD
2858 return wxThread::IsMain();
2859 #else
2860 return true;
2861 #endif
2862 }
2863
2864 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2865 delete self;
2866 }
2867
2868 #include <wx/snglinst.h>
2869
2870
2871 #ifdef __WXMSW__
2872 #include <wx/msw/private.h>
2873 #include <wx/dynload.h>
2874 #endif
2875
2876
2877
2878 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2879 #if 0
2880 , int method
2881 #endif
2882 )
2883 {
2884 #ifdef __WXMSW__
2885 #if 0
2886 switch (method)
2887 {
2888 case 1:
2889 // This one only partially works. Appears to be an undocumented
2890 // "standard" convention that not all widgets adhear to. For
2891 // example, for some widgets backgrounds or non-client areas may
2892 // not be painted.
2893 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2894 break;
2895
2896 case 2:
2897 #endif
2898 // This one works much better, nearly all widgets and their
2899 // children are captured correctly[**]. Prior to the big
2900 // background erase changes that Vadim did in 2004-2005 this
2901 // method failed badly on XP with Themes activated, most native
2902 // widgets draw only partially, if at all. Without themes it
2903 // worked just like on Win2k. After those changes this method
2904 // works very well.
2905 //
2906 // ** For example the radio buttons in a wxRadioBox are not its
2907 // children by default, but you can capture it via the panel
2908 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2909 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2910 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2911 PRF_ERASEBKGND | PRF_OWNED );
2912 return true;
2913 #if 0
2914 break;
2915
2916 case 3:
2917 // This one is only defined in the latest SDK and is only
2918 // available on XP. MSDN says it is similar to sending WM_PRINT
2919 // so I expect that it will work similar to the above. Since it
2920 // is avaialble only on XP, it can't be compiled like this and
2921 // will have to be loaded dynamically.
2922 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2923
2924 // fall through
2925
2926 case 4:
2927 // Use PrintWindow if available, or fallback to WM_PRINT
2928 // otherwise. Unfortunately using PrintWindow is even worse than
2929 // WM_PRINT. For most native widgets nothing is drawn to the dc
2930 // at all, with or without Themes.
2931 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2932 static bool s_triedToLoad = false;
2933 static PrintWindow_t pfnPrintWindow = NULL;
2934 if ( !s_triedToLoad )
2935 {
2936
2937 s_triedToLoad = true;
2938 wxDynamicLibrary dllUser32(_T("user32.dll"));
2939 if ( dllUser32.IsLoaded() )
2940 {
2941 wxLogNull nolog; // Don't report errors here
2942 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2943 }
2944 }
2945 if (pfnPrintWindow)
2946 {
2947 //printf("Using PrintWindow\n");
2948 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2949 }
2950 else
2951 {
2952 //printf("Using WM_PRINT\n");
2953 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2954 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2955 PRF_ERASEBKGND | PRF_OWNED );
2956 }
2957 }
2958 #endif // 0
2959 #else
2960 return false;
2961 #endif // __WXMSW__
2962 }
2963
2964
2965
2966 #include <wx/tipdlg.h>
2967
2968
2969 SWIGINTERNINLINE PyObject *
2970 SWIG_From_size_t (size_t value)
2971 {
2972 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2973 }
2974
2975
2976 class wxPyTipProvider : public wxTipProvider {
2977 public:
2978 wxPyTipProvider(size_t currentTip)
2979 : wxTipProvider(currentTip) {}
2980
2981 DEC_PYCALLBACK_STRING__pure(GetTip);
2982 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2983 PYPRIVATE;
2984 };
2985
2986 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2987 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2988
2989
2990 SWIGINTERNINLINE int
2991 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2992 {
2993 unsigned long v;
2994 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2995 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2996 return res;
2997 }
2998
2999
3000 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3001
3002 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3003
3004 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3005 : wxTimer(owner, id)
3006 {
3007 if (owner == NULL)
3008 SetOwner(this);
3009 }
3010
3011
3012 SWIGINTERN swig_type_info*
3013 SWIG_pchar_descriptor()
3014 {
3015 static int init = 0;
3016 static swig_type_info* info = 0;
3017 if (!init) {
3018 info = SWIG_TypeQuery("_p_char");
3019 init = 1;
3020 }
3021 return info;
3022 }
3023
3024
3025 SWIGINTERNINLINE PyObject *
3026 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3027 {
3028 if (carray) {
3029 if (size > INT_MAX) {
3030 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3031 return pchar_descriptor ?
3032 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3033 } else {
3034 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3035 }
3036 } else {
3037 return SWIG_Py_Void();
3038 }
3039 }
3040
3041
3042 SWIGINTERNINLINE PyObject *
3043 SWIG_FromCharPtr(const char *cptr)
3044 {
3045 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3046 }
3047
3048
3049 SWIGINTERN int
3050 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3051 {
3052 unsigned long v;
3053 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3054 if (SWIG_IsOK(res)) {
3055 if ((v > UINT_MAX)) {
3056 return SWIG_OverflowError;
3057 } else {
3058 if (val) *val = static_cast< unsigned int >(v);
3059 }
3060 }
3061 return res;
3062 }
3063
3064 SWIGINTERN wxString wxLog_TimeStamp(){
3065 wxString msg;
3066 wxLog::TimeStamp(&msg);
3067 return msg;
3068 }
3069 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3070 // Make some wrappers that double any % signs so they are 'escaped'
3071 void wxPyLogFatalError(const wxString& msg)
3072 {
3073 wxString m(msg);
3074 m.Replace(wxT("%"), wxT("%%"));
3075 wxLogFatalError(m);
3076 }
3077
3078 void wxPyLogError(const wxString& msg)
3079 {
3080 wxString m(msg);
3081 m.Replace(wxT("%"), wxT("%%"));
3082 wxLogError(m);
3083 }
3084
3085 void wxPyLogWarning(const wxString& msg)
3086 {
3087 wxString m(msg);
3088 m.Replace(wxT("%"), wxT("%%"));
3089 wxLogWarning(m);
3090 }
3091
3092 void wxPyLogMessage(const wxString& msg)
3093 {
3094 wxString m(msg);
3095 m.Replace(wxT("%"), wxT("%%"));
3096 wxLogMessage(m);
3097 }
3098
3099 void wxPyLogInfo(const wxString& msg)
3100 {
3101 wxString m(msg);
3102 m.Replace(wxT("%"), wxT("%%"));
3103 wxLogInfo(m);
3104 }
3105
3106 void wxPyLogDebug(const wxString& msg)
3107 {
3108 wxString m(msg);
3109 m.Replace(wxT("%"), wxT("%%"));
3110 wxLogDebug(m);
3111 }
3112
3113 void wxPyLogVerbose(const wxString& msg)
3114 {
3115 wxString m(msg);
3116 m.Replace(wxT("%"), wxT("%%"));
3117 wxLogVerbose(m);
3118 }
3119
3120 void wxPyLogStatus(const wxString& msg)
3121 {
3122 wxString m(msg);
3123 m.Replace(wxT("%"), wxT("%%"));
3124 wxLogStatus(m);
3125 }
3126
3127 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3128 {
3129 wxString m(msg);
3130 m.Replace(wxT("%"), wxT("%%"));
3131 wxLogStatus(pFrame, m);
3132 }
3133
3134 void wxPyLogSysError(const wxString& msg)
3135 {
3136 wxString m(msg);
3137 m.Replace(wxT("%"), wxT("%%"));
3138 wxLogSysError(m);
3139 }
3140
3141 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3142 {
3143 wxString m(msg);
3144 m.Replace(wxT("%"), wxT("%%"));
3145 wxLogGeneric(level, m);
3146 }
3147
3148 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3149 {
3150 wxString m(msg);
3151 m.Replace(wxT("%"), wxT("%%"));
3152 wxLogTrace(mask, m);
3153 }
3154
3155 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3156 {
3157 wxString m(msg);
3158 m.Replace(wxT("%"), wxT("%%"));
3159 wxLogTrace(mask, m);
3160 }
3161
3162
3163
3164 // A wxLog class that can be derived from in wxPython
3165 class wxPyLog : public wxLog {
3166 public:
3167 wxPyLog() : wxLog() {}
3168
3169 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3170 bool found;
3171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3172 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3173 PyObject* s = wx2PyString(szString);
3174 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3175 Py_DECREF(s);
3176 }
3177 wxPyEndBlockThreads(blocked);
3178 if (! found)
3179 wxLog::DoLog(level, szString, t);
3180 }
3181
3182 virtual void DoLogString(const wxChar *szString, time_t t) {
3183 bool found;
3184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3185 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3186 PyObject* s = wx2PyString(szString);
3187 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3188 Py_DECREF(s);
3189 }
3190 wxPyEndBlockThreads(blocked);
3191 if (! found)
3192 wxLog::DoLogString(szString, t);
3193 }
3194
3195 DEC_PYCALLBACK_VOID_(Flush);
3196 PYPRIVATE;
3197 };
3198 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3199
3200
3201
3202
3203 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3204
3205
3206 #include <wx/joystick.h>
3207
3208
3209 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3210 // A C++ stub class for wxJoystick for platforms that don't have it.
3211 class wxJoystick : public wxObject {
3212 public:
3213 wxJoystick(int joystick = wxJOYSTICK1) {
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 PyErr_SetString(PyExc_NotImplementedError,
3216 "wxJoystick is not available on this platform.");
3217 wxPyEndBlockThreads(blocked);
3218 }
3219 wxPoint GetPosition() { return wxPoint(-1,-1); }
3220 int GetZPosition() { return -1; }
3221 int GetButtonState() { return -1; }
3222 int GetPOVPosition() { return -1; }
3223 int GetPOVCTSPosition() { return -1; }
3224 int GetRudderPosition() { return -1; }
3225 int GetUPosition() { return -1; }
3226 int GetVPosition() { return -1; }
3227 int GetMovementThreshold() { return -1; }
3228 void SetMovementThreshold(int threshold) {}
3229
3230 bool IsOk(void) { return false; }
3231 int GetNumberJoysticks() { return -1; }
3232 int GetManufacturerId() { return -1; }
3233 int GetProductId() { return -1; }
3234 wxString GetProductName() { return wxEmptyString; }
3235 int GetXMin() { return -1; }
3236 int GetYMin() { return -1; }
3237 int GetZMin() { return -1; }
3238 int GetXMax() { return -1; }
3239 int GetYMax() { return -1; }
3240 int GetZMax() { return -1; }
3241 int GetNumberButtons() { return -1; }
3242 int GetNumberAxes() { return -1; }
3243 int GetMaxButtons() { return -1; }
3244 int GetMaxAxes() { return -1; }
3245 int GetPollingMin() { return -1; }
3246 int GetPollingMax() { return -1; }
3247 int GetRudderMin() { return -1; }
3248 int GetRudderMax() { return -1; }
3249 int GetUMin() { return -1; }
3250 int GetUMax() { return -1; }
3251 int GetVMin() { return -1; }
3252 int GetVMax() { return -1; }
3253
3254 bool HasRudder() { return false; }
3255 bool HasZ() { return false; }
3256 bool HasU() { return false; }
3257 bool HasV() { return false; }
3258 bool HasPOV() { return false; }
3259 bool HasPOV4Dir() { return false; }
3260 bool HasPOVCTS() { return false; }
3261
3262 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3263 bool ReleaseCapture() { return false; }
3264 };
3265 #endif
3266
3267
3268 #include <wx/sound.h>
3269
3270
3271 #if !wxUSE_SOUND
3272 // A C++ stub class for wxWave for platforms that don't have it.
3273 class wxSound : public wxObject
3274 {
3275 public:
3276 wxSound() {
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 PyErr_SetString(PyExc_NotImplementedError,
3279 "wxSound is not available on this platform.");
3280 wxPyEndBlockThreads(blocked);
3281 }
3282 wxSound(const wxString&/*, bool*/) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288 wxSound(int, const wxByte*) {
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 PyErr_SetString(PyExc_NotImplementedError,
3291 "wxSound is not available on this platform.");
3292 wxPyEndBlockThreads(blocked);
3293 }
3294
3295 ~wxSound() {};
3296
3297 bool Create(const wxString&/*, bool*/) { return false; }
3298 bool Create(int, const wxByte*) { return false; };
3299 bool IsOk() { return false; };
3300 bool Play(unsigned) const { return false; }
3301 static bool Play(const wxString&, unsigned) { return false; }
3302 static void Stop() {}
3303 };
3304
3305 #endif
3306
3307 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3308 if (fileName.Length() == 0)
3309 return new wxSound;
3310 else
3311 return new wxSound(fileName);
3312 }
3313 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3314 unsigned char* buffer; int size;
3315 wxSound *sound = NULL;
3316
3317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3318 if (!PyArg_Parse(data, "t#", &buffer, &size))
3319 goto done;
3320 sound = new wxSound(size, buffer);
3321 done:
3322 wxPyEndBlockThreads(blocked);
3323 return sound;
3324 }
3325 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3326 #ifndef __WXMAC__
3327 unsigned char* buffer;
3328 int size;
3329 bool rv = false;
3330
3331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3332 if (!PyArg_Parse(data, "t#", &buffer, &size))
3333 goto done;
3334 rv = self->Create(size, buffer);
3335 done:
3336 wxPyEndBlockThreads(blocked);
3337 return rv;
3338 #else
3339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3340 PyErr_SetString(PyExc_NotImplementedError,
3341 "Create from data is not available on this platform.");
3342 wxPyEndBlockThreads(blocked);
3343 return false;
3344 #endif
3345 }
3346
3347 #include <wx/mimetype.h>
3348
3349 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3350 wxString str;
3351 if (self->GetMimeType(&str))
3352 return wx2PyString(str);
3353 else
3354 RETURN_NONE();
3355 }
3356 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3357 wxArrayString arr;
3358 if (self->GetMimeTypes(arr))
3359 return wxArrayString2PyList_helper(arr);
3360 else
3361 RETURN_NONE();
3362 }
3363 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3364 wxArrayString arr;
3365 if (self->GetExtensions(arr))
3366 return wxArrayString2PyList_helper(arr);
3367 else
3368 RETURN_NONE();
3369 }
3370 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3371 wxIconLocation loc;
3372 if (self->GetIcon(&loc))
3373 return new wxIcon(loc);
3374 else
3375 return NULL;
3376 }
3377 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3378 wxIconLocation loc;
3379 if (self->GetIcon(&loc)) {
3380 wxString iconFile = loc.GetFileName();
3381 int iconIndex = -1;
3382
3383 iconIndex = loc.GetIndex();
3384
3385 // Make a tuple and put the values in it
3386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3387 PyObject* tuple = PyTuple_New(3);
3388 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3389 wxT("wxIcon"), true));
3390 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3391 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3392 wxPyEndBlockThreads(blocked);
3393 return tuple;
3394 }
3395 else
3396 RETURN_NONE();
3397 }
3398 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3399 wxString str;
3400 if (self->GetDescription(&str))
3401 return wx2PyString(str);
3402 else
3403 RETURN_NONE();
3404 }
3405 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3406 wxString str;
3407 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3408 return wx2PyString(str);
3409 else
3410 RETURN_NONE();
3411 }
3412 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3413 wxString str;
3414 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3415 return wx2PyString(str);
3416 else
3417 RETURN_NONE();
3418 }
3419 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3420 wxArrayString verbs;
3421 wxArrayString commands;
3422 if (self->GetAllCommands(&verbs, &commands,
3423 wxFileType::MessageParameters(filename, mimetype))) {
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 PyObject* tuple = PyTuple_New(2);
3426 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3427 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3428 wxPyEndBlockThreads(blocked);
3429 return tuple;
3430 }
3431 else
3432 RETURN_NONE();
3433 }
3434 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3435 return wxFileType::ExpandCommand(command,
3436 wxFileType::MessageParameters(filename, mimetype));
3437 }
3438 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3439 wxArrayString arr;
3440 self->EnumAllFileTypes(arr);
3441 return wxArrayString2PyList_helper(arr);
3442 }
3443
3444 #include <wx/artprov.h>
3445
3446 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3447 static const wxString wxPyART_MENU(wxART_MENU);
3448 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3449 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3450 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3451 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3452 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3453 static const wxString wxPyART_OTHER(wxART_OTHER);
3454 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3455 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3456 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3457 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3458 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3459 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3460 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3461 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3462 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3463 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3464 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3465 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3466 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3467 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3468 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3469 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3470 static const wxString wxPyART_PRINT(wxART_PRINT);
3471 static const wxString wxPyART_HELP(wxART_HELP);
3472 static const wxString wxPyART_TIP(wxART_TIP);
3473 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3474 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3475 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3476 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3477 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3478 static const wxString wxPyART_CDROM(wxART_CDROM);
3479 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3480 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3481 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3482 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3483 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3484 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3485 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3486 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3487 static const wxString wxPyART_ERROR(wxART_ERROR);
3488 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3489 static const wxString wxPyART_WARNING(wxART_WARNING);
3490 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3491 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3492 static const wxString wxPyART_COPY(wxART_COPY);
3493 static const wxString wxPyART_CUT(wxART_CUT);
3494 static const wxString wxPyART_PASTE(wxART_PASTE);
3495 static const wxString wxPyART_DELETE(wxART_DELETE);
3496 static const wxString wxPyART_NEW(wxART_NEW);
3497 static const wxString wxPyART_UNDO(wxART_UNDO);
3498 static const wxString wxPyART_REDO(wxART_REDO);
3499 static const wxString wxPyART_QUIT(wxART_QUIT);
3500 static const wxString wxPyART_FIND(wxART_FIND);
3501 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3502 // Python aware wxArtProvider
3503 class wxPyArtProvider : public wxArtProvider {
3504 public:
3505
3506 virtual wxBitmap CreateBitmap(const wxArtID& id,
3507 const wxArtClient& client,
3508 const wxSize& size) {
3509 wxBitmap rval = wxNullBitmap;
3510 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3511 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3512 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3513 PyObject* ro;
3514 wxBitmap* ptr;
3515 PyObject* s1, *s2;
3516 s1 = wx2PyString(id);
3517 s2 = wx2PyString(client);
3518 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3519 Py_DECREF(so);
3520 Py_DECREF(s1);
3521 Py_DECREF(s2);
3522 if (ro) {
3523 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3524 rval = *ptr;
3525 Py_DECREF(ro);
3526 }
3527 }
3528 wxPyEndBlockThreads(blocked);
3529 return rval;
3530 }
3531
3532 PYPRIVATE;
3533 };
3534
3535 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3536
3537
3538
3539 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3540 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3541 PyObject* ret = PyTuple_New(3);
3542 if (ret) {
3543 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3544 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3545 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3546 }
3547 wxPyEndBlockThreads(blocked);
3548 return ret;
3549 }
3550
3551 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3552 bool cont;
3553 long index = 0;
3554 wxString value;
3555
3556 cont = self->GetFirstGroup(value, index);
3557 return __EnumerationHelper(cont, value, index);
3558 }
3559 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3560 bool cont;
3561 wxString value;
3562
3563 cont = self->GetNextGroup(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3567 bool cont;
3568 long index = 0;
3569 wxString value;
3570
3571 cont = self->GetFirstEntry(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3575 bool cont;
3576 wxString value;
3577
3578 cont = self->GetNextEntry(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3582 long rv;
3583 self->Read(key, &rv, defaultVal);
3584 return rv;
3585 }
3586
3587 SWIGINTERN int
3588 SWIG_AsVal_double (PyObject *obj, double* val)
3589 {
3590 if (PyNumber_Check(obj)) {
3591 if (val) *val = PyFloat_AsDouble(obj);
3592 return SWIG_OK;
3593 }
3594 return SWIG_TypeError;
3595 }
3596
3597 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3598 double rv;
3599 self->Read(key, &rv, defaultVal);
3600 return rv;
3601 }
3602
3603 #define SWIG_From_double PyFloat_FromDouble
3604
3605 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3606 bool rv;
3607 self->Read(key, &rv, defaultVal);
3608 return rv;
3609 }
3610
3611 #include <wx/datetime.h>
3612
3613 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3614 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3615
3616 #define LOCAL_TZ wxDateTime::Local
3617
3618 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3619 wxString am;
3620 wxString pm;
3621 wxDateTime::GetAmPmStrings(&am, &pm);
3622 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3623 PyObject* tup = PyTuple_New(2);
3624 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3625 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3626 wxPyEndBlockThreads(blocked);
3627 return tup;
3628 }
3629
3630 SWIGINTERNINLINE PyObject *
3631 SWIG_From_unsigned_SS_int (unsigned int value)
3632 {
3633 return SWIG_From_unsigned_SS_long (value);
3634 }
3635
3636 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3638 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3639 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3641 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3642 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3643 return (*self < *other);
3644 }
3645 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3646 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3647 return (*self <= *other);
3648 }
3649 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3651 return (*self > *other);
3652 }
3653 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3655 return (*self >= *other);
3656 }
3657 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3659 return (*self == *other);
3660 }
3661 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3662 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3663 return (*self != *other);
3664 }
3665 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3666 const wxChar* rv;
3667 const wxChar* _date = date;
3668 rv = self->ParseRfc822Date(_date);
3669 if (rv == NULL) return -1;
3670 return rv - _date;
3671 }
3672 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3673 const wxChar* rv;
3674 const wxChar* _date = date;
3675 rv = self->ParseFormat(_date, format, dateDef);
3676 if (rv == NULL) return -1;
3677 return rv - _date;
3678 }
3679 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3680 const wxChar* rv;
3681 const wxChar* _datetime = datetime;
3682 rv = self->ParseDateTime(_datetime);
3683 if (rv == NULL) return -1;
3684 return rv - _datetime;
3685 }
3686 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3687 const wxChar* rv;
3688 const wxChar* _date = date;
3689 rv = self->ParseDate(_date);
3690 if (rv == NULL) return -1;
3691 return rv - _date;
3692 }
3693 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3694 const wxChar* rv;
3695 const wxChar* _time = time;
3696 rv = self->ParseTime(_time);
3697 if (rv == NULL) return -1;
3698 return rv - _time;
3699 }
3700 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3704 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3705 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3707 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3709 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3710 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3711 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3713 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3714 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3715 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3716
3717 #include <wx/dataobj.h>
3718
3719 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3720 size_t count = self->GetFormatCount(dir);
3721 wxDataFormat* formats = new wxDataFormat[count];
3722 self->GetAllFormats(formats, dir);
3723
3724 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3725 PyObject* list = PyList_New(count);
3726 for (size_t i=0; i<count; i++) {
3727 wxDataFormat* format = new wxDataFormat(formats[i]);
3728 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3729 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3730 }
3731 wxPyEndBlockThreads(blocked);
3732 delete [] formats;
3733 return list;
3734 }
3735 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3736 PyObject* rval = NULL;
3737 size_t size = self->GetDataSize(format);
3738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3739 if (size) {
3740 char* buf = new char[size];
3741 if (self->GetDataHere(format, buf))
3742 rval = PyString_FromStringAndSize(buf, size);
3743 delete [] buf;
3744 }
3745 if (! rval) {
3746 rval = Py_None;
3747 Py_INCREF(rval);
3748 }
3749 wxPyEndBlockThreads(blocked);
3750 return rval;
3751 }
3752 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3753 bool rval;
3754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3755 if (PyString_Check(data)) {
3756 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3757 }
3758 else {
3759 // raise a TypeError if not a string
3760 PyErr_SetString(PyExc_TypeError, "String expected.");
3761 rval = false;
3762 }
3763 wxPyEndBlockThreads(blocked);
3764 return rval;
3765 }
3766 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3767 PyObject* rval = NULL;
3768 size_t size = self->GetDataSize();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 if (size) {
3771 char* buf = new char[size];
3772 if (self->GetDataHere(buf))
3773 rval = PyString_FromStringAndSize(buf, size);
3774 delete [] buf;
3775 }
3776 if (! rval) {
3777 rval = Py_None;
3778 Py_INCREF(rval);
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return rval;
3782 }
3783 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3784 bool rval;
3785 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3786 if (PyString_Check(data)) {
3787 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3788 }
3789 else {
3790 // raise a TypeError if not a string
3791 PyErr_SetString(PyExc_TypeError, "String expected.");
3792 rval = false;
3793 }
3794 wxPyEndBlockThreads(blocked);
3795 return rval;
3796 }
3797 // Create a new class for wxPython to use
3798 class wxPyDataObjectSimple : public wxDataObjectSimple {
3799 public:
3800 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3801 : wxDataObjectSimple(format) {}
3802
3803 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3804 bool GetDataHere(void *buf) const;
3805 bool SetData(size_t len, const void *buf) const;
3806 PYPRIVATE;
3807 };
3808
3809 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3810
3811 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3812 // We need to get the data for this object and write it to buf. I think
3813 // the best way to do this for wxPython is to have the Python method
3814 // return either a string or None and then act appropriately with the
3815 // C++ version.
3816
3817 bool rval = false;
3818 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3819 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3820 PyObject* ro;
3821 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3822 if (ro) {
3823 rval = (ro != Py_None && PyString_Check(ro));
3824 if (rval)
3825 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3826 Py_DECREF(ro);
3827 }
3828 }
3829 wxPyEndBlockThreads(blocked);
3830 return rval;
3831 }
3832
3833 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3834 // For this one we simply need to make a string from buf and len
3835 // and send it to the Python method.
3836 bool rval = false;
3837 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3838 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3839 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3840 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3841 Py_DECREF(data);
3842 }
3843 wxPyEndBlockThreads(blocked);
3844 return rval;
3845 }
3846
3847 // Create a new class for wxPython to use
3848 class wxPyTextDataObject : public wxTextDataObject {
3849 public:
3850 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3851 : wxTextDataObject(text) {}
3852
3853 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3854 DEC_PYCALLBACK_STRING__const(GetText);
3855 DEC_PYCALLBACK__STRING(SetText);
3856 PYPRIVATE;
3857 };
3858
3859 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3860 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3861 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3862
3863
3864 // Create a new class for wxPython to use
3865 class wxPyBitmapDataObject : public wxBitmapDataObject {
3866 public:
3867 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3868 : wxBitmapDataObject(bitmap) {}
3869
3870 wxBitmap GetBitmap() const;
3871 void SetBitmap(const wxBitmap& bitmap);
3872 PYPRIVATE;
3873 };
3874
3875 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3876 wxBitmap* rval = &wxNullBitmap;
3877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3878 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3879 PyObject* ro;
3880 wxBitmap* ptr;
3881 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3882 if (ro) {
3883 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3884 rval = ptr;
3885 Py_DECREF(ro);
3886 }
3887 }
3888 wxPyEndBlockThreads(blocked);
3889 return *rval;
3890 }
3891
3892 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3893 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3894 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3895 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3896 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3897 Py_DECREF(bo);
3898 }
3899 wxPyEndBlockThreads(blocked);
3900 }
3901
3902 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3903 return new wxCustomDataObject(wxDataFormat(formatName));
3904 }
3905 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3906 bool rval;
3907 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3908 if (PyString_Check(data)) {
3909 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3910 }
3911 else {
3912 // raise a TypeError if not a string
3913 PyErr_SetString(PyExc_TypeError, "String expected.");
3914 rval = false;
3915 }
3916 wxPyEndBlockThreads(blocked);
3917 return rval;
3918 }
3919 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3920 PyObject* obj;
3921 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3922 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3923 wxPyEndBlockThreads(blocked);
3924 return obj;
3925 }
3926
3927 #include <wx/metafile.h>
3928
3929
3930 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3931
3932
3933 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3934 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3935 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3936 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3937 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3938
3939
3940 class wxPyTextDropTarget : public wxTextDropTarget {
3941 public:
3942 wxPyTextDropTarget() {}
3943
3944 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3945
3946 DEC_PYCALLBACK__(OnLeave);
3947 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3950 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3951
3952 PYPRIVATE;
3953 };
3954
3955 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3956 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3957 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3960 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3961
3962
3963
3964 class wxPyFileDropTarget : public wxFileDropTarget {
3965 public:
3966 wxPyFileDropTarget() {}
3967
3968 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3969
3970 DEC_PYCALLBACK__(OnLeave);
3971 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3974 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3975
3976 PYPRIVATE;
3977 };
3978
3979 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3980 const wxArrayString& filenames) {
3981 bool rval = false;
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3984 PyObject* list = wxArrayString2PyList_helper(filenames);
3985 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3986 Py_DECREF(list);
3987 }
3988 wxPyEndBlockThreads(blocked);
3989 return rval;
3990 }
3991
3992
3993
3994 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3995 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3998 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3999
4000
4001
4002
4003 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4004
4005 #include <wx/display.h>
4006
4007 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4008 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4009
4010 #if !wxUSE_DISPLAY
4011 const wxVideoMode wxDefaultVideoMode;
4012 #endif
4013
4014 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4015 #if wxUSE_DISPLAY
4016 PyObject* pyList = NULL;
4017 wxArrayVideoModes arr = self->GetModes(mode);
4018 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4019 pyList = PyList_New(0);
4020 for (size_t i=0; i < arr.GetCount(); i++)
4021 {
4022 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4023 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4024 PyList_Append(pyList, pyObj);
4025 Py_DECREF(pyObj);
4026 }
4027 wxPyEndBlockThreads(blocked);
4028 return pyList;
4029 #else
4030 wxPyRaiseNotImplemented();
4031 return NULL;
4032 #endif
4033 }
4034 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4035 #if wxUSE_DISPLAY
4036 return self->GetCurrentMode();
4037 #else
4038 wxPyRaiseNotImplemented();
4039 return wxDefaultVideoMode;
4040 #endif
4041 }
4042 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4043 #if wxUSE_DISPLAY
4044 return self->ChangeMode(mode);
4045 #else
4046 wxPyRaiseNotImplemented();
4047 return false;
4048 #endif
4049 }
4050 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4051 #if wxUSE_DISPLAY
4052 self->ResetMode();
4053 #else
4054 wxPyRaiseNotImplemented();
4055 #endif
4056 }
4057
4058 #include <wx/stdpaths.h>
4059
4060 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4061 return (wxStandardPaths*) &wxStandardPaths::Get();
4062 }
4063 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4064 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4065
4066 #ifndef wxHAS_POWER_EVENTS
4067 // Dummy class and other definitions for platforms that don't have them
4068
4069 // See wxPython_int.h for wxPowerEvent
4070
4071 enum {
4072 wxEVT_POWER_SUSPENDING,
4073 wxEVT_POWER_SUSPENDED,
4074 wxEVT_POWER_SUSPEND_CANCEL,
4075 wxEVT_POWER_RESUME,
4076 };
4077
4078 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4079 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4080
4081 #endif
4082
4083 #ifdef __cplusplus
4084 extern "C" {
4085 #endif
4086 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4087 PyObject *resultobj = 0;
4088 wxSystemColour arg1 ;
4089 wxColour result;
4090 int val1 ;
4091 int ecode1 = 0 ;
4092 PyObject * obj0 = 0 ;
4093 char * kwnames[] = {
4094 (char *) "index", NULL
4095 };
4096
4097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4098 ecode1 = SWIG_AsVal_int(obj0, &val1);
4099 if (!SWIG_IsOK(ecode1)) {
4100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4101 }
4102 arg1 = static_cast< wxSystemColour >(val1);
4103 {
4104 if (!wxPyCheckForApp()) SWIG_fail;
4105 PyThreadState* __tstate = wxPyBeginAllowThreads();
4106 result = wxSystemSettings::GetColour(arg1);
4107 wxPyEndAllowThreads(__tstate);
4108 if (PyErr_Occurred()) SWIG_fail;
4109 }
4110 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4111 return resultobj;
4112 fail:
4113 return NULL;
4114 }
4115
4116
4117 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4118 PyObject *resultobj = 0;
4119 wxSystemFont arg1 ;
4120 wxFont result;
4121 int val1 ;
4122 int ecode1 = 0 ;
4123 PyObject * obj0 = 0 ;
4124 char * kwnames[] = {
4125 (char *) "index", NULL
4126 };
4127
4128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4129 ecode1 = SWIG_AsVal_int(obj0, &val1);
4130 if (!SWIG_IsOK(ecode1)) {
4131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4132 }
4133 arg1 = static_cast< wxSystemFont >(val1);
4134 {
4135 if (!wxPyCheckForApp()) SWIG_fail;
4136 PyThreadState* __tstate = wxPyBeginAllowThreads();
4137 result = wxSystemSettings::GetFont(arg1);
4138 wxPyEndAllowThreads(__tstate);
4139 if (PyErr_Occurred()) SWIG_fail;
4140 }
4141 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj = 0;
4150 wxSystemMetric arg1 ;
4151 wxWindow *arg2 = (wxWindow *) NULL ;
4152 int result;
4153 int val1 ;
4154 int ecode1 = 0 ;
4155 void *argp2 = 0 ;
4156 int res2 = 0 ;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 char * kwnames[] = {
4160 (char *) "index",(char *) "win", NULL
4161 };
4162
4163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4164 ecode1 = SWIG_AsVal_int(obj0, &val1);
4165 if (!SWIG_IsOK(ecode1)) {
4166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4167 }
4168 arg1 = static_cast< wxSystemMetric >(val1);
4169 if (obj1) {
4170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4171 if (!SWIG_IsOK(res2)) {
4172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4173 }
4174 arg2 = reinterpret_cast< wxWindow * >(argp2);
4175 }
4176 {
4177 if (!wxPyCheckForApp()) SWIG_fail;
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4180 wxPyEndAllowThreads(__tstate);
4181 if (PyErr_Occurred()) SWIG_fail;
4182 }
4183 resultobj = SWIG_From_int(static_cast< int >(result));
4184 return resultobj;
4185 fail:
4186 return NULL;
4187 }
4188
4189
4190 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4191 PyObject *resultobj = 0;
4192 wxSystemFeature arg1 ;
4193 bool result;
4194 int val1 ;
4195 int ecode1 = 0 ;
4196 PyObject * obj0 = 0 ;
4197 char * kwnames[] = {
4198 (char *) "index", NULL
4199 };
4200
4201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4202 ecode1 = SWIG_AsVal_int(obj0, &val1);
4203 if (!SWIG_IsOK(ecode1)) {
4204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4205 }
4206 arg1 = static_cast< wxSystemFeature >(val1);
4207 {
4208 if (!wxPyCheckForApp()) SWIG_fail;
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (bool)wxSystemSettings::HasFeature(arg1);
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4216 }
4217 return resultobj;
4218 fail:
4219 return NULL;
4220 }
4221
4222
4223 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4224 PyObject *resultobj = 0;
4225 wxSystemScreenType result;
4226
4227 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4228 {
4229 if (!wxPyCheckForApp()) SWIG_fail;
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 resultobj = SWIG_From_int(static_cast< int >(result));
4236 return resultobj;
4237 fail:
4238 return NULL;
4239 }
4240
4241
4242 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4243 PyObject *resultobj = 0;
4244 wxSystemScreenType arg1 ;
4245 int val1 ;
4246 int ecode1 = 0 ;
4247 PyObject * obj0 = 0 ;
4248 char * kwnames[] = {
4249 (char *) "screen", NULL
4250 };
4251
4252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4253 ecode1 = SWIG_AsVal_int(obj0, &val1);
4254 if (!SWIG_IsOK(ecode1)) {
4255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4256 }
4257 arg1 = static_cast< wxSystemScreenType >(val1);
4258 {
4259 if (!wxPyCheckForApp()) SWIG_fail;
4260 PyThreadState* __tstate = wxPyBeginAllowThreads();
4261 wxSystemSettings::SetScreenType(arg1);
4262 wxPyEndAllowThreads(__tstate);
4263 if (PyErr_Occurred()) SWIG_fail;
4264 }
4265 resultobj = SWIG_Py_Void();
4266 return resultobj;
4267 fail:
4268 return NULL;
4269 }
4270
4271
4272 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4273 PyObject *obj;
4274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4275 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4276 return SWIG_Py_Void();
4277 }
4278
4279 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4280 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4281 return 1;
4282 }
4283
4284
4285 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4286 PyObject *pyobj = 0;
4287
4288 {
4289 #if wxUSE_UNICODE
4290 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4291 #else
4292 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4293 #endif
4294 }
4295 return pyobj;
4296 }
4297
4298
4299 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4300 PyObject *resultobj = 0;
4301 wxSystemOptions *result = 0 ;
4302
4303 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4304 {
4305 PyThreadState* __tstate = wxPyBeginAllowThreads();
4306 result = (wxSystemOptions *)new wxSystemOptions();
4307 wxPyEndAllowThreads(__tstate);
4308 if (PyErr_Occurred()) SWIG_fail;
4309 }
4310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4311 return resultobj;
4312 fail:
4313 return NULL;
4314 }
4315
4316
4317 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4318 PyObject *resultobj = 0;
4319 wxString *arg1 = 0 ;
4320 wxString *arg2 = 0 ;
4321 bool temp1 = false ;
4322 bool temp2 = false ;
4323 PyObject * obj0 = 0 ;
4324 PyObject * obj1 = 0 ;
4325 char * kwnames[] = {
4326 (char *) "name",(char *) "value", NULL
4327 };
4328
4329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4330 {
4331 arg1 = wxString_in_helper(obj0);
4332 if (arg1 == NULL) SWIG_fail;
4333 temp1 = true;
4334 }
4335 {
4336 arg2 = wxString_in_helper(obj1);
4337 if (arg2 == NULL) SWIG_fail;
4338 temp2 = true;
4339 }
4340 {
4341 PyThreadState* __tstate = wxPyBeginAllowThreads();
4342 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4343 wxPyEndAllowThreads(__tstate);
4344 if (PyErr_Occurred()) SWIG_fail;
4345 }
4346 resultobj = SWIG_Py_Void();
4347 {
4348 if (temp1)
4349 delete arg1;
4350 }
4351 {
4352 if (temp2)
4353 delete arg2;
4354 }
4355 return resultobj;
4356 fail:
4357 {
4358 if (temp1)
4359 delete arg1;
4360 }
4361 {
4362 if (temp2)
4363 delete arg2;
4364 }
4365 return NULL;
4366 }
4367
4368
4369 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj = 0;
4371 wxString *arg1 = 0 ;
4372 int arg2 ;
4373 bool temp1 = false ;
4374 int val2 ;
4375 int ecode2 = 0 ;
4376 PyObject * obj0 = 0 ;
4377 PyObject * obj1 = 0 ;
4378 char * kwnames[] = {
4379 (char *) "name",(char *) "value", NULL
4380 };
4381
4382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4383 {
4384 arg1 = wxString_in_helper(obj0);
4385 if (arg1 == NULL) SWIG_fail;
4386 temp1 = true;
4387 }
4388 ecode2 = SWIG_AsVal_int(obj1, &val2);
4389 if (!SWIG_IsOK(ecode2)) {
4390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4391 }
4392 arg2 = static_cast< int >(val2);
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 resultobj = SWIG_Py_Void();
4400 {
4401 if (temp1)
4402 delete arg1;
4403 }
4404 return resultobj;
4405 fail:
4406 {
4407 if (temp1)
4408 delete arg1;
4409 }
4410 return NULL;
4411 }
4412
4413
4414 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4415 PyObject *resultobj = 0;
4416 wxString *arg1 = 0 ;
4417 wxString result;
4418 bool temp1 = false ;
4419 PyObject * obj0 = 0 ;
4420 char * kwnames[] = {
4421 (char *) "name", NULL
4422 };
4423
4424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4425 {
4426 arg1 = wxString_in_helper(obj0);
4427 if (arg1 == NULL) SWIG_fail;
4428 temp1 = true;
4429 }
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 #if wxUSE_UNICODE
4438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4439 #else
4440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4441 #endif
4442 }
4443 {
4444 if (temp1)
4445 delete arg1;
4446 }
4447 return resultobj;
4448 fail:
4449 {
4450 if (temp1)
4451 delete arg1;
4452 }
4453 return NULL;
4454 }
4455
4456
4457 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4458 PyObject *resultobj = 0;
4459 wxString *arg1 = 0 ;
4460 int result;
4461 bool temp1 = false ;
4462 PyObject * obj0 = 0 ;
4463 char * kwnames[] = {
4464 (char *) "name", NULL
4465 };
4466
4467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4468 {
4469 arg1 = wxString_in_helper(obj0);
4470 if (arg1 == NULL) SWIG_fail;
4471 temp1 = true;
4472 }
4473 {
4474 PyThreadState* __tstate = wxPyBeginAllowThreads();
4475 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 resultobj = SWIG_From_int(static_cast< int >(result));
4480 {
4481 if (temp1)
4482 delete arg1;
4483 }
4484 return resultobj;
4485 fail:
4486 {
4487 if (temp1)
4488 delete arg1;
4489 }
4490 return NULL;
4491 }
4492
4493
4494 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj = 0;
4496 wxString *arg1 = 0 ;
4497 bool result;
4498 bool temp1 = false ;
4499 PyObject * obj0 = 0 ;
4500 char * kwnames[] = {
4501 (char *) "name", NULL
4502 };
4503
4504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4505 {
4506 arg1 = wxString_in_helper(obj0);
4507 if (arg1 == NULL) SWIG_fail;
4508 temp1 = true;
4509 }
4510 {
4511 PyThreadState* __tstate = wxPyBeginAllowThreads();
4512 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4513 wxPyEndAllowThreads(__tstate);
4514 if (PyErr_Occurred()) SWIG_fail;
4515 }
4516 {
4517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4518 }
4519 {
4520 if (temp1)
4521 delete arg1;
4522 }
4523 return resultobj;
4524 fail:
4525 {
4526 if (temp1)
4527 delete arg1;
4528 }
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4534 PyObject *resultobj = 0;
4535 wxString *arg1 = 0 ;
4536 bool result;
4537 bool temp1 = false ;
4538 PyObject * obj0 = 0 ;
4539 char * kwnames[] = {
4540 (char *) "name", NULL
4541 };
4542
4543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4544 {
4545 arg1 = wxString_in_helper(obj0);
4546 if (arg1 == NULL) SWIG_fail;
4547 temp1 = true;
4548 }
4549 {
4550 PyThreadState* __tstate = wxPyBeginAllowThreads();
4551 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4552 wxPyEndAllowThreads(__tstate);
4553 if (PyErr_Occurred()) SWIG_fail;
4554 }
4555 {
4556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4557 }
4558 {
4559 if (temp1)
4560 delete arg1;
4561 }
4562 return resultobj;
4563 fail:
4564 {
4565 if (temp1)
4566 delete arg1;
4567 }
4568 return NULL;
4569 }
4570
4571
4572 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573 PyObject *obj;
4574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4575 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4576 return SWIG_Py_Void();
4577 }
4578
4579 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580 return SWIG_Python_InitShadowInstance(args);
4581 }
4582
4583 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4584 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4585 return 1;
4586 }
4587
4588
4589 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4590 PyObject *pyobj = 0;
4591
4592 {
4593 #if wxUSE_UNICODE
4594 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4595 #else
4596 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4597 #endif
4598 }
4599 return pyobj;
4600 }
4601
4602
4603 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4604 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4605 return 1;
4606 }
4607
4608
4609 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4610 PyObject *pyobj = 0;
4611
4612 {
4613 #if wxUSE_UNICODE
4614 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4615 #else
4616 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4617 #endif
4618 }
4619 return pyobj;
4620 }
4621
4622
4623 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4624 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4625 return 1;
4626 }
4627
4628
4629 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4630 PyObject *pyobj = 0;
4631
4632 {
4633 #if wxUSE_UNICODE
4634 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4635 #else
4636 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4637 #endif
4638 }
4639 return pyobj;
4640 }
4641
4642
4643 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4644 PyObject *resultobj = 0;
4645 long result;
4646
4647 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4648 {
4649 PyThreadState* __tstate = wxPyBeginAllowThreads();
4650 result = (long)wxNewId();
4651 wxPyEndAllowThreads(__tstate);
4652 if (PyErr_Occurred()) SWIG_fail;
4653 }
4654 resultobj = SWIG_From_long(static_cast< long >(result));
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj = 0;
4663 long arg1 ;
4664 long val1 ;
4665 int ecode1 = 0 ;
4666 PyObject * obj0 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "id", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4672 ecode1 = SWIG_AsVal_long(obj0, &val1);
4673 if (!SWIG_IsOK(ecode1)) {
4674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4675 }
4676 arg1 = static_cast< long >(val1);
4677 {
4678 PyThreadState* __tstate = wxPyBeginAllowThreads();
4679 wxRegisterId(arg1);
4680 wxPyEndAllowThreads(__tstate);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 resultobj = SWIG_Py_Void();
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4691 PyObject *resultobj = 0;
4692 long result;
4693
4694 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4695 {
4696 PyThreadState* __tstate = wxPyBeginAllowThreads();
4697 result = (long)wxGetCurrentId();
4698 wxPyEndAllowThreads(__tstate);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 resultobj = SWIG_From_long(static_cast< long >(result));
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = 0;
4710 int arg1 ;
4711 bool result;
4712 int val1 ;
4713 int ecode1 = 0 ;
4714 PyObject * obj0 = 0 ;
4715 char * kwnames[] = {
4716 (char *) "id", NULL
4717 };
4718
4719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4720 ecode1 = SWIG_AsVal_int(obj0, &val1);
4721 if (!SWIG_IsOK(ecode1)) {
4722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4723 }
4724 arg1 = static_cast< int >(val1);
4725 {
4726 PyThreadState* __tstate = wxPyBeginAllowThreads();
4727 result = (bool)wxIsStockID(arg1);
4728 wxPyEndAllowThreads(__tstate);
4729 if (PyErr_Occurred()) SWIG_fail;
4730 }
4731 {
4732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4733 }
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj = 0;
4742 int arg1 ;
4743 wxString *arg2 = 0 ;
4744 bool result;
4745 int val1 ;
4746 int ecode1 = 0 ;
4747 bool temp2 = false ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
4751 (char *) "id",(char *) "label", NULL
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4755 ecode1 = SWIG_AsVal_int(obj0, &val1);
4756 if (!SWIG_IsOK(ecode1)) {
4757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4758 }
4759 arg1 = static_cast< int >(val1);
4760 {
4761 arg2 = wxString_in_helper(obj1);
4762 if (arg2 == NULL) SWIG_fail;
4763 temp2 = true;
4764 }
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 {
4772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4773 }
4774 {
4775 if (temp2)
4776 delete arg2;
4777 }
4778 return resultobj;
4779 fail:
4780 {
4781 if (temp2)
4782 delete arg2;
4783 }
4784 return NULL;
4785 }
4786
4787
4788 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4789 PyObject *resultobj = 0;
4790 int arg1 ;
4791 bool arg2 = (bool) true ;
4792 wxString arg3 = (wxString) wxPyEmptyString ;
4793 wxString result;
4794 int val1 ;
4795 int ecode1 = 0 ;
4796 bool val2 ;
4797 int ecode2 = 0 ;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4800 PyObject * obj2 = 0 ;
4801 char * kwnames[] = {
4802 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4803 };
4804
4805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4806 ecode1 = SWIG_AsVal_int(obj0, &val1);
4807 if (!SWIG_IsOK(ecode1)) {
4808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4809 }
4810 arg1 = static_cast< int >(val1);
4811 if (obj1) {
4812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4813 if (!SWIG_IsOK(ecode2)) {
4814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4815 }
4816 arg2 = static_cast< bool >(val2);
4817 }
4818 if (obj2) {
4819 {
4820 wxString* sptr = wxString_in_helper(obj2);
4821 if (sptr == NULL) SWIG_fail;
4822 arg3 = *sptr;
4823 delete sptr;
4824 }
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 result = wxGetStockLabel(arg1,arg2,arg3);
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 {
4833 #if wxUSE_UNICODE
4834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4835 #else
4836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4837 #endif
4838 }
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846 PyObject *resultobj = 0;
4847
4848 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4849 {
4850 if (!wxPyCheckForApp()) SWIG_fail;
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 wxBell();
4853 wxPyEndAllowThreads(__tstate);
4854 if (PyErr_Occurred()) SWIG_fail;
4855 }
4856 resultobj = SWIG_Py_Void();
4857 return resultobj;
4858 fail:
4859 return NULL;
4860 }
4861
4862
4863 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4864 PyObject *resultobj = 0;
4865
4866 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4867 {
4868 if (!wxPyCheckForApp()) SWIG_fail;
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 wxEndBusyCursor();
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_Py_Void();
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 bool arg1 = (bool) true ;
4884 long result;
4885 bool val1 ;
4886 int ecode1 = 0 ;
4887 PyObject * obj0 = 0 ;
4888 char * kwnames[] = {
4889 (char *) "resetTimer", NULL
4890 };
4891
4892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4893 if (obj0) {
4894 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4895 if (!SWIG_IsOK(ecode1)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4897 }
4898 arg1 = static_cast< bool >(val1);
4899 }
4900 {
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 result = (long)wxGetElapsedTime(arg1);
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_From_long(static_cast< long >(result));
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4914 PyObject *resultobj = 0;
4915 bool result;
4916
4917 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 result = (bool)wxIsBusy();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 {
4925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4926 }
4927 return resultobj;
4928 fail:
4929 return NULL;
4930 }
4931
4932
4933 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4934 PyObject *resultobj = 0;
4935 wxString result;
4936
4937 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = wxNow();
4941 wxPyEndAllowThreads(__tstate);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 {
4945 #if wxUSE_UNICODE
4946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4947 #else
4948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4949 #endif
4950 }
4951 return resultobj;
4952 fail:
4953 return NULL;
4954 }
4955
4956
4957 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4958 PyObject *resultobj = 0;
4959 wxString const &arg1_defvalue = wxPyEmptyString ;
4960 wxString *arg1 = (wxString *) &arg1_defvalue ;
4961 bool result;
4962 bool temp1 = false ;
4963 PyObject * obj0 = 0 ;
4964 char * kwnames[] = {
4965 (char *) "command", NULL
4966 };
4967
4968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4969 if (obj0) {
4970 {
4971 arg1 = wxString_in_helper(obj0);
4972 if (arg1 == NULL) SWIG_fail;
4973 temp1 = true;
4974 }
4975 }
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (bool)wxShell((wxString const &)*arg1);
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4984 }
4985 {
4986 if (temp1)
4987 delete arg1;
4988 }
4989 return resultobj;
4990 fail:
4991 {
4992 if (temp1)
4993 delete arg1;
4994 }
4995 return NULL;
4996 }
4997
4998
4999 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5000 PyObject *resultobj = 0;
5001
5002 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5003 {
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 wxStartTimer();
5006 wxPyEndAllowThreads(__tstate);
5007 if (PyErr_Occurred()) SWIG_fail;
5008 }
5009 resultobj = SWIG_Py_Void();
5010 return resultobj;
5011 fail:
5012 return NULL;
5013 }
5014
5015
5016 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5017 PyObject *resultobj = 0;
5018 int *arg1 = (int *) 0 ;
5019 int *arg2 = (int *) 0 ;
5020 int result;
5021 int temp1 ;
5022 int res1 = SWIG_TMPOBJ ;
5023 int temp2 ;
5024 int res2 = SWIG_TMPOBJ ;
5025
5026 arg1 = &temp1;
5027 arg2 = &temp2;
5028 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5029 {
5030 PyThreadState* __tstate = wxPyBeginAllowThreads();
5031 result = (int)wxGetOsVersion(arg1,arg2);
5032 wxPyEndAllowThreads(__tstate);
5033 if (PyErr_Occurred()) SWIG_fail;
5034 }
5035 resultobj = SWIG_From_int(static_cast< int >(result));
5036 if (SWIG_IsTmpObj(res1)) {
5037 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5038 } else {
5039 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5040 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5041 }
5042 if (SWIG_IsTmpObj(res2)) {
5043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5044 } else {
5045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5055 PyObject *resultobj = 0;
5056 wxString result;
5057
5058 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5059 {
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 result = wxGetOsDescription();
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 {
5066 #if wxUSE_UNICODE
5067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5068 #else
5069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5070 #endif
5071 }
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5079 PyObject *resultobj = 0;
5080 wxMemorySize result;
5081
5082 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = wxGetFreeMemory();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5097 PyObject *resultobj = 0;
5098 wxShutdownFlags arg1 ;
5099 bool result;
5100 int val1 ;
5101 int ecode1 = 0 ;
5102 PyObject * obj0 = 0 ;
5103 char * kwnames[] = {
5104 (char *) "wFlags", NULL
5105 };
5106
5107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5108 ecode1 = SWIG_AsVal_int(obj0, &val1);
5109 if (!SWIG_IsOK(ecode1)) {
5110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5111 }
5112 arg1 = static_cast< wxShutdownFlags >(val1);
5113 {
5114 if (!wxPyCheckForApp()) SWIG_fail;
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 result = (bool)wxShutdown(arg1);
5117 wxPyEndAllowThreads(__tstate);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 {
5121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5122 }
5123 return resultobj;
5124 fail:
5125 return NULL;
5126 }
5127
5128
5129 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5130 PyObject *resultobj = 0;
5131 int arg1 ;
5132 int val1 ;
5133 int ecode1 = 0 ;
5134 PyObject * obj0 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "secs", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5140 ecode1 = SWIG_AsVal_int(obj0, &val1);
5141 if (!SWIG_IsOK(ecode1)) {
5142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5143 }
5144 arg1 = static_cast< int >(val1);
5145 {
5146 PyThreadState* __tstate = wxPyBeginAllowThreads();
5147 wxSleep(arg1);
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 resultobj = SWIG_Py_Void();
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5159 PyObject *resultobj = 0;
5160 unsigned long arg1 ;
5161 unsigned long val1 ;
5162 int ecode1 = 0 ;
5163 PyObject * obj0 = 0 ;
5164 char * kwnames[] = {
5165 (char *) "milliseconds", NULL
5166 };
5167
5168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5169 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5170 if (!SWIG_IsOK(ecode1)) {
5171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5172 }
5173 arg1 = static_cast< unsigned long >(val1);
5174 {
5175 PyThreadState* __tstate = wxPyBeginAllowThreads();
5176 wxMilliSleep(arg1);
5177 wxPyEndAllowThreads(__tstate);
5178 if (PyErr_Occurred()) SWIG_fail;
5179 }
5180 resultobj = SWIG_Py_Void();
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj = 0;
5189 unsigned long arg1 ;
5190 unsigned long val1 ;
5191 int ecode1 = 0 ;
5192 PyObject * obj0 = 0 ;
5193 char * kwnames[] = {
5194 (char *) "microseconds", NULL
5195 };
5196
5197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5198 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5199 if (!SWIG_IsOK(ecode1)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5201 }
5202 arg1 = static_cast< unsigned long >(val1);
5203 {
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 wxMicroSleep(arg1);
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 resultobj = SWIG_Py_Void();
5210 return resultobj;
5211 fail:
5212 return NULL;
5213 }
5214
5215
5216 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5217 PyObject *resultobj = 0;
5218 bool arg1 ;
5219 bool val1 ;
5220 int ecode1 = 0 ;
5221 PyObject * obj0 = 0 ;
5222 char * kwnames[] = {
5223 (char *) "enable", NULL
5224 };
5225
5226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5227 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5228 if (!SWIG_IsOK(ecode1)) {
5229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5230 }
5231 arg1 = static_cast< bool >(val1);
5232 {
5233 PyThreadState* __tstate = wxPyBeginAllowThreads();
5234 wxEnableTopLevelWindows(arg1);
5235 wxPyEndAllowThreads(__tstate);
5236 if (PyErr_Occurred()) SWIG_fail;
5237 }
5238 resultobj = SWIG_Py_Void();
5239 return resultobj;
5240 fail:
5241 return NULL;
5242 }
5243
5244
5245 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj = 0;
5247 wxString *arg1 = 0 ;
5248 wxString result;
5249 bool temp1 = false ;
5250 PyObject * obj0 = 0 ;
5251 char * kwnames[] = {
5252 (char *) "in", NULL
5253 };
5254
5255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5256 {
5257 arg1 = wxString_in_helper(obj0);
5258 if (arg1 == NULL) SWIG_fail;
5259 temp1 = true;
5260 }
5261 {
5262 PyThreadState* __tstate = wxPyBeginAllowThreads();
5263 result = wxStripMenuCodes((wxString const &)*arg1);
5264 wxPyEndAllowThreads(__tstate);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 {
5268 #if wxUSE_UNICODE
5269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5270 #else
5271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5272 #endif
5273 }
5274 {
5275 if (temp1)
5276 delete arg1;
5277 }
5278 return resultobj;
5279 fail:
5280 {
5281 if (temp1)
5282 delete arg1;
5283 }
5284 return NULL;
5285 }
5286
5287
5288 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5289 PyObject *resultobj = 0;
5290 wxString result;
5291
5292 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 result = wxGetEmailAddress();
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 {
5300 #if wxUSE_UNICODE
5301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5302 #else
5303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5304 #endif
5305 }
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313 PyObject *resultobj = 0;
5314 wxString result;
5315
5316 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 result = wxGetHostName();
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 {
5324 #if wxUSE_UNICODE
5325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5326 #else
5327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5328 #endif
5329 }
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5337 PyObject *resultobj = 0;
5338 wxString result;
5339
5340 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5341 {
5342 PyThreadState* __tstate = wxPyBeginAllowThreads();
5343 result = wxGetFullHostName();
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 {
5348 #if wxUSE_UNICODE
5349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5350 #else
5351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5352 #endif
5353 }
5354 return resultobj;
5355 fail:
5356 return NULL;
5357 }
5358
5359
5360 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5361 PyObject *resultobj = 0;
5362 wxString result;
5363
5364 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5365 {
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 result = wxGetUserId();
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 #if wxUSE_UNICODE
5373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5374 #else
5375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5376 #endif
5377 }
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxString result;
5387
5388 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = wxGetUserName();
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 {
5396 #if wxUSE_UNICODE
5397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5398 #else
5399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5400 #endif
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5409 PyObject *resultobj = 0;
5410 wxString result;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5413 {
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 result = wxGetHomeDir();
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 #if wxUSE_UNICODE
5421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5422 #else
5423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5424 #endif
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5433 PyObject *resultobj = 0;
5434 wxString const &arg1_defvalue = wxPyEmptyString ;
5435 wxString *arg1 = (wxString *) &arg1_defvalue ;
5436 wxString result;
5437 bool temp1 = false ;
5438 PyObject * obj0 = 0 ;
5439 char * kwnames[] = {
5440 (char *) "user", NULL
5441 };
5442
5443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5444 if (obj0) {
5445 {
5446 arg1 = wxString_in_helper(obj0);
5447 if (arg1 == NULL) SWIG_fail;
5448 temp1 = true;
5449 }
5450 }
5451 {
5452 PyThreadState* __tstate = wxPyBeginAllowThreads();
5453 result = wxGetUserHome((wxString const &)*arg1);
5454 wxPyEndAllowThreads(__tstate);
5455 if (PyErr_Occurred()) SWIG_fail;
5456 }
5457 {
5458 #if wxUSE_UNICODE
5459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5460 #else
5461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5462 #endif
5463 }
5464 {
5465 if (temp1)
5466 delete arg1;
5467 }
5468 return resultobj;
5469 fail:
5470 {
5471 if (temp1)
5472 delete arg1;
5473 }
5474 return NULL;
5475 }
5476
5477
5478 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5479 PyObject *resultobj = 0;
5480 unsigned long result;
5481
5482 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5483 {
5484 PyThreadState* __tstate = wxPyBeginAllowThreads();
5485 result = (unsigned long)wxGetProcessId();
5486 wxPyEndAllowThreads(__tstate);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498
5499 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5500 {
5501 PyThreadState* __tstate = wxPyBeginAllowThreads();
5502 wxTrap();
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 resultobj = SWIG_Py_Void();
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5514 PyObject *resultobj = 0;
5515 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5516 wxString *arg1 = (wxString *) &arg1_defvalue ;
5517 wxString const &arg2_defvalue = wxPyEmptyString ;
5518 wxString *arg2 = (wxString *) &arg2_defvalue ;
5519 wxString const &arg3_defvalue = wxPyEmptyString ;
5520 wxString *arg3 = (wxString *) &arg3_defvalue ;
5521 wxString const &arg4_defvalue = wxPyEmptyString ;
5522 wxString *arg4 = (wxString *) &arg4_defvalue ;
5523 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5524 wxString *arg5 = (wxString *) &arg5_defvalue ;
5525 int arg6 = (int) 0 ;
5526 wxWindow *arg7 = (wxWindow *) NULL ;
5527 int arg8 = (int) -1 ;
5528 int arg9 = (int) -1 ;
5529 wxString result;
5530 bool temp1 = false ;
5531 bool temp2 = false ;
5532 bool temp3 = false ;
5533 bool temp4 = false ;
5534 bool temp5 = false ;
5535 int val6 ;
5536 int ecode6 = 0 ;
5537 void *argp7 = 0 ;
5538 int res7 = 0 ;
5539 int val8 ;
5540 int ecode8 = 0 ;
5541 int val9 ;
5542 int ecode9 = 0 ;
5543 PyObject * obj0 = 0 ;
5544 PyObject * obj1 = 0 ;
5545 PyObject * obj2 = 0 ;
5546 PyObject * obj3 = 0 ;
5547 PyObject * obj4 = 0 ;
5548 PyObject * obj5 = 0 ;
5549 PyObject * obj6 = 0 ;
5550 PyObject * obj7 = 0 ;
5551 PyObject * obj8 = 0 ;
5552 char * kwnames[] = {
5553 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5554 };
5555
5556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5557 if (obj0) {
5558 {
5559 arg1 = wxString_in_helper(obj0);
5560 if (arg1 == NULL) SWIG_fail;
5561 temp1 = true;
5562 }
5563 }
5564 if (obj1) {
5565 {
5566 arg2 = wxString_in_helper(obj1);
5567 if (arg2 == NULL) SWIG_fail;
5568 temp2 = true;
5569 }
5570 }
5571 if (obj2) {
5572 {
5573 arg3 = wxString_in_helper(obj2);
5574 if (arg3 == NULL) SWIG_fail;
5575 temp3 = true;
5576 }
5577 }
5578 if (obj3) {
5579 {
5580 arg4 = wxString_in_helper(obj3);
5581 if (arg4 == NULL) SWIG_fail;
5582 temp4 = true;
5583 }
5584 }
5585 if (obj4) {
5586 {
5587 arg5 = wxString_in_helper(obj4);
5588 if (arg5 == NULL) SWIG_fail;
5589 temp5 = true;
5590 }
5591 }
5592 if (obj5) {
5593 ecode6 = SWIG_AsVal_int(obj5, &val6);
5594 if (!SWIG_IsOK(ecode6)) {
5595 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5596 }
5597 arg6 = static_cast< int >(val6);
5598 }
5599 if (obj6) {
5600 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5601 if (!SWIG_IsOK(res7)) {
5602 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5603 }
5604 arg7 = reinterpret_cast< wxWindow * >(argp7);
5605 }
5606 if (obj7) {
5607 ecode8 = SWIG_AsVal_int(obj7, &val8);
5608 if (!SWIG_IsOK(ecode8)) {
5609 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5610 }
5611 arg8 = static_cast< int >(val8);
5612 }
5613 if (obj8) {
5614 ecode9 = SWIG_AsVal_int(obj8, &val9);
5615 if (!SWIG_IsOK(ecode9)) {
5616 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5617 }
5618 arg9 = static_cast< int >(val9);
5619 }
5620 {
5621 if (!wxPyCheckForApp()) SWIG_fail;
5622 PyThreadState* __tstate = wxPyBeginAllowThreads();
5623 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5624 wxPyEndAllowThreads(__tstate);
5625 if (PyErr_Occurred()) SWIG_fail;
5626 }
5627 {
5628 #if wxUSE_UNICODE
5629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5630 #else
5631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5632 #endif
5633 }
5634 {
5635 if (temp1)
5636 delete arg1;
5637 }
5638 {
5639 if (temp2)
5640 delete arg2;
5641 }
5642 {
5643 if (temp3)
5644 delete arg3;
5645 }
5646 {
5647 if (temp4)
5648 delete arg4;
5649 }
5650 {
5651 if (temp5)
5652 delete arg5;
5653 }
5654 return resultobj;
5655 fail:
5656 {
5657 if (temp1)
5658 delete arg1;
5659 }
5660 {
5661 if (temp2)
5662 delete arg2;
5663 }
5664 {
5665 if (temp3)
5666 delete arg3;
5667 }
5668 {
5669 if (temp4)
5670 delete arg4;
5671 }
5672 {
5673 if (temp5)
5674 delete arg5;
5675 }
5676 return NULL;
5677 }
5678
5679
5680 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5681 PyObject *resultobj = 0;
5682 wxString *arg1 = 0 ;
5683 wxString *arg2 = 0 ;
5684 wxString const &arg3_defvalue = wxPyEmptyString ;
5685 wxString *arg3 = (wxString *) &arg3_defvalue ;
5686 wxWindow *arg4 = (wxWindow *) NULL ;
5687 wxString result;
5688 bool temp1 = false ;
5689 bool temp2 = false ;
5690 bool temp3 = false ;
5691 void *argp4 = 0 ;
5692 int res4 = 0 ;
5693 PyObject * obj0 = 0 ;
5694 PyObject * obj1 = 0 ;
5695 PyObject * obj2 = 0 ;
5696 PyObject * obj3 = 0 ;
5697 char * kwnames[] = {
5698 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5699 };
5700
5701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5702 {
5703 arg1 = wxString_in_helper(obj0);
5704 if (arg1 == NULL) SWIG_fail;
5705 temp1 = true;
5706 }
5707 {
5708 arg2 = wxString_in_helper(obj1);
5709 if (arg2 == NULL) SWIG_fail;
5710 temp2 = true;
5711 }
5712 if (obj2) {
5713 {
5714 arg3 = wxString_in_helper(obj2);
5715 if (arg3 == NULL) SWIG_fail;
5716 temp3 = true;
5717 }
5718 }
5719 if (obj3) {
5720 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5721 if (!SWIG_IsOK(res4)) {
5722 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5723 }
5724 arg4 = reinterpret_cast< wxWindow * >(argp4);
5725 }
5726 {
5727 if (!wxPyCheckForApp()) SWIG_fail;
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5730 wxPyEndAllowThreads(__tstate);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 {
5734 #if wxUSE_UNICODE
5735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5736 #else
5737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5738 #endif
5739 }
5740 {
5741 if (temp1)
5742 delete arg1;
5743 }
5744 {
5745 if (temp2)
5746 delete arg2;
5747 }
5748 {
5749 if (temp3)
5750 delete arg3;
5751 }
5752 return resultobj;
5753 fail:
5754 {
5755 if (temp1)
5756 delete arg1;
5757 }
5758 {
5759 if (temp2)
5760 delete arg2;
5761 }
5762 {
5763 if (temp3)
5764 delete arg3;
5765 }
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj = 0;
5772 wxString *arg1 = 0 ;
5773 wxString *arg2 = 0 ;
5774 wxString const &arg3_defvalue = wxPyEmptyString ;
5775 wxString *arg3 = (wxString *) &arg3_defvalue ;
5776 wxWindow *arg4 = (wxWindow *) NULL ;
5777 wxString result;
5778 bool temp1 = false ;
5779 bool temp2 = false ;
5780 bool temp3 = false ;
5781 void *argp4 = 0 ;
5782 int res4 = 0 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 PyObject * obj2 = 0 ;
5786 PyObject * obj3 = 0 ;
5787 char * kwnames[] = {
5788 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5789 };
5790
5791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5792 {
5793 arg1 = wxString_in_helper(obj0);
5794 if (arg1 == NULL) SWIG_fail;
5795 temp1 = true;
5796 }
5797 {
5798 arg2 = wxString_in_helper(obj1);
5799 if (arg2 == NULL) SWIG_fail;
5800 temp2 = true;
5801 }
5802 if (obj2) {
5803 {
5804 arg3 = wxString_in_helper(obj2);
5805 if (arg3 == NULL) SWIG_fail;
5806 temp3 = true;
5807 }
5808 }
5809 if (obj3) {
5810 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5811 if (!SWIG_IsOK(res4)) {
5812 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5813 }
5814 arg4 = reinterpret_cast< wxWindow * >(argp4);
5815 }
5816 {
5817 if (!wxPyCheckForApp()) SWIG_fail;
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 {
5824 #if wxUSE_UNICODE
5825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5826 #else
5827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5828 #endif
5829 }
5830 {
5831 if (temp1)
5832 delete arg1;
5833 }
5834 {
5835 if (temp2)
5836 delete arg2;
5837 }
5838 {
5839 if (temp3)
5840 delete arg3;
5841 }
5842 return resultobj;
5843 fail:
5844 {
5845 if (temp1)
5846 delete arg1;
5847 }
5848 {
5849 if (temp2)
5850 delete arg2;
5851 }
5852 {
5853 if (temp3)
5854 delete arg3;
5855 }
5856 return NULL;
5857 }
5858
5859
5860 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5861 PyObject *resultobj = 0;
5862 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5863 wxString *arg1 = (wxString *) &arg1_defvalue ;
5864 wxString const &arg2_defvalue = wxPyEmptyString ;
5865 wxString *arg2 = (wxString *) &arg2_defvalue ;
5866 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5867 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5868 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5869 wxWindow *arg5 = (wxWindow *) NULL ;
5870 wxString result;
5871 bool temp1 = false ;
5872 bool temp2 = false ;
5873 long val3 ;
5874 int ecode3 = 0 ;
5875 wxPoint temp4 ;
5876 void *argp5 = 0 ;
5877 int res5 = 0 ;
5878 PyObject * obj0 = 0 ;
5879 PyObject * obj1 = 0 ;
5880 PyObject * obj2 = 0 ;
5881 PyObject * obj3 = 0 ;
5882 PyObject * obj4 = 0 ;
5883 char * kwnames[] = {
5884 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5885 };
5886
5887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5888 if (obj0) {
5889 {
5890 arg1 = wxString_in_helper(obj0);
5891 if (arg1 == NULL) SWIG_fail;
5892 temp1 = true;
5893 }
5894 }
5895 if (obj1) {
5896 {
5897 arg2 = wxString_in_helper(obj1);
5898 if (arg2 == NULL) SWIG_fail;
5899 temp2 = true;
5900 }
5901 }
5902 if (obj2) {
5903 ecode3 = SWIG_AsVal_long(obj2, &val3);
5904 if (!SWIG_IsOK(ecode3)) {
5905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5906 }
5907 arg3 = static_cast< long >(val3);
5908 }
5909 if (obj3) {
5910 {
5911 arg4 = &temp4;
5912 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5913 }
5914 }
5915 if (obj4) {
5916 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5917 if (!SWIG_IsOK(res5)) {
5918 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5919 }
5920 arg5 = reinterpret_cast< wxWindow * >(argp5);
5921 }
5922 {
5923 if (!wxPyCheckForApp()) SWIG_fail;
5924 PyThreadState* __tstate = wxPyBeginAllowThreads();
5925 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5926 wxPyEndAllowThreads(__tstate);
5927 if (PyErr_Occurred()) SWIG_fail;
5928 }
5929 {
5930 #if wxUSE_UNICODE
5931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5932 #else
5933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5934 #endif
5935 }
5936 {
5937 if (temp1)
5938 delete arg1;
5939 }
5940 {
5941 if (temp2)
5942 delete arg2;
5943 }
5944 return resultobj;
5945 fail:
5946 {
5947 if (temp1)
5948 delete arg1;
5949 }
5950 {
5951 if (temp2)
5952 delete arg2;
5953 }
5954 return NULL;
5955 }
5956
5957
5958 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5959 PyObject *resultobj = 0;
5960 wxString *arg1 = 0 ;
5961 wxString const &arg2_defvalue = wxPyEmptyString ;
5962 wxString *arg2 = (wxString *) &arg2_defvalue ;
5963 wxString const &arg3_defvalue = wxPyEmptyString ;
5964 wxString *arg3 = (wxString *) &arg3_defvalue ;
5965 wxWindow *arg4 = (wxWindow *) NULL ;
5966 int arg5 = (int) -1 ;
5967 int arg6 = (int) -1 ;
5968 bool arg7 = (bool) true ;
5969 wxString result;
5970 bool temp1 = false ;
5971 bool temp2 = false ;
5972 bool temp3 = false ;
5973 void *argp4 = 0 ;
5974 int res4 = 0 ;
5975 int val5 ;
5976 int ecode5 = 0 ;
5977 int val6 ;
5978 int ecode6 = 0 ;
5979 bool val7 ;
5980 int ecode7 = 0 ;
5981 PyObject * obj0 = 0 ;
5982 PyObject * obj1 = 0 ;
5983 PyObject * obj2 = 0 ;
5984 PyObject * obj3 = 0 ;
5985 PyObject * obj4 = 0 ;
5986 PyObject * obj5 = 0 ;
5987 PyObject * obj6 = 0 ;
5988 char * kwnames[] = {
5989 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5990 };
5991
5992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5993 {
5994 arg1 = wxString_in_helper(obj0);
5995 if (arg1 == NULL) SWIG_fail;
5996 temp1 = true;
5997 }
5998 if (obj1) {
5999 {
6000 arg2 = wxString_in_helper(obj1);
6001 if (arg2 == NULL) SWIG_fail;
6002 temp2 = true;
6003 }
6004 }
6005 if (obj2) {
6006 {
6007 arg3 = wxString_in_helper(obj2);
6008 if (arg3 == NULL) SWIG_fail;
6009 temp3 = true;
6010 }
6011 }
6012 if (obj3) {
6013 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6014 if (!SWIG_IsOK(res4)) {
6015 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6016 }
6017 arg4 = reinterpret_cast< wxWindow * >(argp4);
6018 }
6019 if (obj4) {
6020 ecode5 = SWIG_AsVal_int(obj4, &val5);
6021 if (!SWIG_IsOK(ecode5)) {
6022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6023 }
6024 arg5 = static_cast< int >(val5);
6025 }
6026 if (obj5) {
6027 ecode6 = SWIG_AsVal_int(obj5, &val6);
6028 if (!SWIG_IsOK(ecode6)) {
6029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6030 }
6031 arg6 = static_cast< int >(val6);
6032 }
6033 if (obj6) {
6034 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6035 if (!SWIG_IsOK(ecode7)) {
6036 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6037 }
6038 arg7 = static_cast< bool >(val7);
6039 }
6040 {
6041 if (!wxPyCheckForApp()) SWIG_fail;
6042 PyThreadState* __tstate = wxPyBeginAllowThreads();
6043 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6044 wxPyEndAllowThreads(__tstate);
6045 if (PyErr_Occurred()) SWIG_fail;
6046 }
6047 {
6048 #if wxUSE_UNICODE
6049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6050 #else
6051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6052 #endif
6053 }
6054 {
6055 if (temp1)
6056 delete arg1;
6057 }
6058 {
6059 if (temp2)
6060 delete arg2;
6061 }
6062 {
6063 if (temp3)
6064 delete arg3;
6065 }
6066 return resultobj;
6067 fail:
6068 {
6069 if (temp1)
6070 delete arg1;
6071 }
6072 {
6073 if (temp2)
6074 delete arg2;
6075 }
6076 {
6077 if (temp3)
6078 delete arg3;
6079 }
6080 return NULL;
6081 }
6082
6083
6084 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj = 0;
6086 wxString *arg1 = 0 ;
6087 wxString const &arg2_defvalue = wxPyEmptyString ;
6088 wxString *arg2 = (wxString *) &arg2_defvalue ;
6089 wxString const &arg3_defvalue = wxPyEmptyString ;
6090 wxString *arg3 = (wxString *) &arg3_defvalue ;
6091 wxWindow *arg4 = (wxWindow *) NULL ;
6092 wxString result;
6093 bool temp1 = false ;
6094 bool temp2 = false ;
6095 bool temp3 = false ;
6096 void *argp4 = 0 ;
6097 int res4 = 0 ;
6098 PyObject * obj0 = 0 ;
6099 PyObject * obj1 = 0 ;
6100 PyObject * obj2 = 0 ;
6101 PyObject * obj3 = 0 ;
6102 char * kwnames[] = {
6103 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6104 };
6105
6106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6107 {
6108 arg1 = wxString_in_helper(obj0);
6109 if (arg1 == NULL) SWIG_fail;
6110 temp1 = true;
6111 }
6112 if (obj1) {
6113 {
6114 arg2 = wxString_in_helper(obj1);
6115 if (arg2 == NULL) SWIG_fail;
6116 temp2 = true;
6117 }
6118 }
6119 if (obj2) {
6120 {
6121 arg3 = wxString_in_helper(obj2);
6122 if (arg3 == NULL) SWIG_fail;
6123 temp3 = true;
6124 }
6125 }
6126 if (obj3) {
6127 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6128 if (!SWIG_IsOK(res4)) {
6129 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6130 }
6131 arg4 = reinterpret_cast< wxWindow * >(argp4);
6132 }
6133 {
6134 if (!wxPyCheckForApp()) SWIG_fail;
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6137 wxPyEndAllowThreads(__tstate);
6138 if (PyErr_Occurred()) SWIG_fail;
6139 }
6140 {
6141 #if wxUSE_UNICODE
6142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6143 #else
6144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6145 #endif
6146 }
6147 {
6148 if (temp1)
6149 delete arg1;
6150 }
6151 {
6152 if (temp2)
6153 delete arg2;
6154 }
6155 {
6156 if (temp3)
6157 delete arg3;
6158 }
6159 return resultobj;
6160 fail:
6161 {
6162 if (temp1)
6163 delete arg1;
6164 }
6165 {
6166 if (temp2)
6167 delete arg2;
6168 }
6169 {
6170 if (temp3)
6171 delete arg3;
6172 }
6173 return NULL;
6174 }
6175
6176
6177 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6178 PyObject *resultobj = 0;
6179 wxString *arg1 = 0 ;
6180 wxString *arg2 = 0 ;
6181 int arg3 ;
6182 wxString *arg4 = (wxString *) 0 ;
6183 wxWindow *arg5 = (wxWindow *) NULL ;
6184 int arg6 = (int) -1 ;
6185 int arg7 = (int) -1 ;
6186 bool arg8 = (bool) true ;
6187 int arg9 = (int) 150 ;
6188 int arg10 = (int) 200 ;
6189 wxString result;
6190 bool temp1 = false ;
6191 bool temp2 = false ;
6192 void *argp5 = 0 ;
6193 int res5 = 0 ;
6194 int val6 ;
6195 int ecode6 = 0 ;
6196 int val7 ;
6197 int ecode7 = 0 ;
6198 bool val8 ;
6199 int ecode8 = 0 ;
6200 int val9 ;
6201 int ecode9 = 0 ;
6202 int val10 ;
6203 int ecode10 = 0 ;
6204 PyObject * obj0 = 0 ;
6205 PyObject * obj1 = 0 ;
6206 PyObject * obj2 = 0 ;
6207 PyObject * obj3 = 0 ;
6208 PyObject * obj4 = 0 ;
6209 PyObject * obj5 = 0 ;
6210 PyObject * obj6 = 0 ;
6211 PyObject * obj7 = 0 ;
6212 PyObject * obj8 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6218 {
6219 arg1 = wxString_in_helper(obj0);
6220 if (arg1 == NULL) SWIG_fail;
6221 temp1 = true;
6222 }
6223 {
6224 arg2 = wxString_in_helper(obj1);
6225 if (arg2 == NULL) SWIG_fail;
6226 temp2 = true;
6227 }
6228 {
6229 arg3 = PyList_Size(obj2);
6230 arg4 = wxString_LIST_helper(obj2);
6231 if (arg4 == NULL) SWIG_fail;
6232 }
6233 if (obj3) {
6234 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6235 if (!SWIG_IsOK(res5)) {
6236 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6237 }
6238 arg5 = reinterpret_cast< wxWindow * >(argp5);
6239 }
6240 if (obj4) {
6241 ecode6 = SWIG_AsVal_int(obj4, &val6);
6242 if (!SWIG_IsOK(ecode6)) {
6243 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6244 }
6245 arg6 = static_cast< int >(val6);
6246 }
6247 if (obj5) {
6248 ecode7 = SWIG_AsVal_int(obj5, &val7);
6249 if (!SWIG_IsOK(ecode7)) {
6250 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6251 }
6252 arg7 = static_cast< int >(val7);
6253 }
6254 if (obj6) {
6255 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6256 if (!SWIG_IsOK(ecode8)) {
6257 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6258 }
6259 arg8 = static_cast< bool >(val8);
6260 }
6261 if (obj7) {
6262 ecode9 = SWIG_AsVal_int(obj7, &val9);
6263 if (!SWIG_IsOK(ecode9)) {
6264 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6265 }
6266 arg9 = static_cast< int >(val9);
6267 }
6268 if (obj8) {
6269 ecode10 = SWIG_AsVal_int(obj8, &val10);
6270 if (!SWIG_IsOK(ecode10)) {
6271 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6272 }
6273 arg10 = static_cast< int >(val10);
6274 }
6275 {
6276 if (!wxPyCheckForApp()) SWIG_fail;
6277 PyThreadState* __tstate = wxPyBeginAllowThreads();
6278 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6279 wxPyEndAllowThreads(__tstate);
6280 if (PyErr_Occurred()) SWIG_fail;
6281 }
6282 {
6283 #if wxUSE_UNICODE
6284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6285 #else
6286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6287 #endif
6288 }
6289 {
6290 if (temp1)
6291 delete arg1;
6292 }
6293 {
6294 if (temp2)
6295 delete arg2;
6296 }
6297 {
6298 if (arg4) delete [] arg4;
6299 }
6300 return resultobj;
6301 fail:
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 NULL;
6314 }
6315
6316
6317 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj = 0;
6319 wxString *arg1 = 0 ;
6320 wxString *arg2 = 0 ;
6321 int arg3 ;
6322 wxString *arg4 = (wxString *) 0 ;
6323 wxWindow *arg5 = (wxWindow *) NULL ;
6324 int arg6 = (int) -1 ;
6325 int arg7 = (int) -1 ;
6326 bool arg8 = (bool) true ;
6327 int arg9 = (int) 150 ;
6328 int arg10 = (int) 200 ;
6329 int result;
6330 bool temp1 = false ;
6331 bool temp2 = false ;
6332 void *argp5 = 0 ;
6333 int res5 = 0 ;
6334 int val6 ;
6335 int ecode6 = 0 ;
6336 int val7 ;
6337 int ecode7 = 0 ;
6338 bool val8 ;
6339 int ecode8 = 0 ;
6340 int val9 ;
6341 int ecode9 = 0 ;
6342 int val10 ;
6343 int ecode10 = 0 ;
6344 PyObject * obj0 = 0 ;
6345 PyObject * obj1 = 0 ;
6346 PyObject * obj2 = 0 ;
6347 PyObject * obj3 = 0 ;
6348 PyObject * obj4 = 0 ;
6349 PyObject * obj5 = 0 ;
6350 PyObject * obj6 = 0 ;
6351 PyObject * obj7 = 0 ;
6352 PyObject * obj8 = 0 ;
6353 char * kwnames[] = {
6354 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6355 };
6356
6357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6358 {
6359 arg1 = wxString_in_helper(obj0);
6360 if (arg1 == NULL) SWIG_fail;
6361 temp1 = true;
6362 }
6363 {
6364 arg2 = wxString_in_helper(obj1);
6365 if (arg2 == NULL) SWIG_fail;
6366 temp2 = true;
6367 }
6368 {
6369 arg3 = PyList_Size(obj2);
6370 arg4 = wxString_LIST_helper(obj2);
6371 if (arg4 == NULL) SWIG_fail;
6372 }
6373 if (obj3) {
6374 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6375 if (!SWIG_IsOK(res5)) {
6376 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6377 }
6378 arg5 = reinterpret_cast< wxWindow * >(argp5);
6379 }
6380 if (obj4) {
6381 ecode6 = SWIG_AsVal_int(obj4, &val6);
6382 if (!SWIG_IsOK(ecode6)) {
6383 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6384 }
6385 arg6 = static_cast< int >(val6);
6386 }
6387 if (obj5) {
6388 ecode7 = SWIG_AsVal_int(obj5, &val7);
6389 if (!SWIG_IsOK(ecode7)) {
6390 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6391 }
6392 arg7 = static_cast< int >(val7);
6393 }
6394 if (obj6) {
6395 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6396 if (!SWIG_IsOK(ecode8)) {
6397 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6398 }
6399 arg8 = static_cast< bool >(val8);
6400 }
6401 if (obj7) {
6402 ecode9 = SWIG_AsVal_int(obj7, &val9);
6403 if (!SWIG_IsOK(ecode9)) {
6404 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6405 }
6406 arg9 = static_cast< int >(val9);
6407 }
6408 if (obj8) {
6409 ecode10 = SWIG_AsVal_int(obj8, &val10);
6410 if (!SWIG_IsOK(ecode10)) {
6411 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6412 }
6413 arg10 = static_cast< int >(val10);
6414 }
6415 {
6416 if (!wxPyCheckForApp()) SWIG_fail;
6417 PyThreadState* __tstate = wxPyBeginAllowThreads();
6418 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6419 wxPyEndAllowThreads(__tstate);
6420 if (PyErr_Occurred()) SWIG_fail;
6421 }
6422 resultobj = SWIG_From_int(static_cast< int >(result));
6423 {
6424 if (temp1)
6425 delete arg1;
6426 }
6427 {
6428 if (temp2)
6429 delete arg2;
6430 }
6431 {
6432 if (arg4) delete [] arg4;
6433 }
6434 return resultobj;
6435 fail:
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 NULL;
6448 }
6449
6450
6451 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6452 PyObject *resultobj = 0;
6453 wxString *arg1 = 0 ;
6454 wxString const &arg2_defvalue = wxPyEmptyString ;
6455 wxString *arg2 = (wxString *) &arg2_defvalue ;
6456 int arg3 = (int) wxOK|wxCENTRE ;
6457 wxWindow *arg4 = (wxWindow *) NULL ;
6458 int arg5 = (int) -1 ;
6459 int arg6 = (int) -1 ;
6460 int result;
6461 bool temp1 = false ;
6462 bool temp2 = false ;
6463 int val3 ;
6464 int ecode3 = 0 ;
6465 void *argp4 = 0 ;
6466 int res4 = 0 ;
6467 int val5 ;
6468 int ecode5 = 0 ;
6469 int val6 ;
6470 int ecode6 = 0 ;
6471 PyObject * obj0 = 0 ;
6472 PyObject * obj1 = 0 ;
6473 PyObject * obj2 = 0 ;
6474 PyObject * obj3 = 0 ;
6475 PyObject * obj4 = 0 ;
6476 PyObject * obj5 = 0 ;
6477 char * kwnames[] = {
6478 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6479 };
6480
6481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6482 {
6483 arg1 = wxString_in_helper(obj0);
6484 if (arg1 == NULL) SWIG_fail;
6485 temp1 = true;
6486 }
6487 if (obj1) {
6488 {
6489 arg2 = wxString_in_helper(obj1);
6490 if (arg2 == NULL) SWIG_fail;
6491 temp2 = true;
6492 }
6493 }
6494 if (obj2) {
6495 ecode3 = SWIG_AsVal_int(obj2, &val3);
6496 if (!SWIG_IsOK(ecode3)) {
6497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6498 }
6499 arg3 = static_cast< int >(val3);
6500 }
6501 if (obj3) {
6502 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6503 if (!SWIG_IsOK(res4)) {
6504 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6505 }
6506 arg4 = reinterpret_cast< wxWindow * >(argp4);
6507 }
6508 if (obj4) {
6509 ecode5 = SWIG_AsVal_int(obj4, &val5);
6510 if (!SWIG_IsOK(ecode5)) {
6511 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6512 }
6513 arg5 = static_cast< int >(val5);
6514 }
6515 if (obj5) {
6516 ecode6 = SWIG_AsVal_int(obj5, &val6);
6517 if (!SWIG_IsOK(ecode6)) {
6518 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6519 }
6520 arg6 = static_cast< int >(val6);
6521 }
6522 {
6523 if (!wxPyCheckForApp()) SWIG_fail;
6524 PyThreadState* __tstate = wxPyBeginAllowThreads();
6525 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6526 wxPyEndAllowThreads(__tstate);
6527 if (PyErr_Occurred()) SWIG_fail;
6528 }
6529 resultobj = SWIG_From_int(static_cast< int >(result));
6530 {
6531 if (temp1)
6532 delete arg1;
6533 }
6534 {
6535 if (temp2)
6536 delete arg2;
6537 }
6538 return resultobj;
6539 fail:
6540 {
6541 if (temp1)
6542 delete arg1;
6543 }
6544 {
6545 if (temp2)
6546 delete arg2;
6547 }
6548 return NULL;
6549 }
6550
6551
6552 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6553 PyObject *resultobj = 0;
6554 wxString *arg1 = 0 ;
6555 wxString *arg2 = 0 ;
6556 wxString *arg3 = 0 ;
6557 long arg4 ;
6558 long arg5 = (long) 0 ;
6559 long arg6 = (long) 100 ;
6560 wxWindow *arg7 = (wxWindow *) NULL ;
6561 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6562 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6563 long result;
6564 bool temp1 = false ;
6565 bool temp2 = false ;
6566 bool temp3 = false ;
6567 long val4 ;
6568 int ecode4 = 0 ;
6569 long val5 ;
6570 int ecode5 = 0 ;
6571 long val6 ;
6572 int ecode6 = 0 ;
6573 void *argp7 = 0 ;
6574 int res7 = 0 ;
6575 wxPoint temp8 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 PyObject * obj2 = 0 ;
6579 PyObject * obj3 = 0 ;
6580 PyObject * obj4 = 0 ;
6581 PyObject * obj5 = 0 ;
6582 PyObject * obj6 = 0 ;
6583 PyObject * obj7 = 0 ;
6584 char * kwnames[] = {
6585 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6586 };
6587
6588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6589 {
6590 arg1 = wxString_in_helper(obj0);
6591 if (arg1 == NULL) SWIG_fail;
6592 temp1 = true;
6593 }
6594 {
6595 arg2 = wxString_in_helper(obj1);
6596 if (arg2 == NULL) SWIG_fail;
6597 temp2 = true;
6598 }
6599 {
6600 arg3 = wxString_in_helper(obj2);
6601 if (arg3 == NULL) SWIG_fail;
6602 temp3 = true;
6603 }
6604 ecode4 = SWIG_AsVal_long(obj3, &val4);
6605 if (!SWIG_IsOK(ecode4)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6607 }
6608 arg4 = static_cast< long >(val4);
6609 if (obj4) {
6610 ecode5 = SWIG_AsVal_long(obj4, &val5);
6611 if (!SWIG_IsOK(ecode5)) {
6612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6613 }
6614 arg5 = static_cast< long >(val5);
6615 }
6616 if (obj5) {
6617 ecode6 = SWIG_AsVal_long(obj5, &val6);
6618 if (!SWIG_IsOK(ecode6)) {
6619 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6620 }
6621 arg6 = static_cast< long >(val6);
6622 }
6623 if (obj6) {
6624 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6625 if (!SWIG_IsOK(res7)) {
6626 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6627 }
6628 arg7 = reinterpret_cast< wxWindow * >(argp7);
6629 }
6630 if (obj7) {
6631 {
6632 arg8 = &temp8;
6633 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6634 }
6635 }
6636 {
6637 if (!wxPyCheckForApp()) SWIG_fail;
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_From_long(static_cast< long >(result));
6644 {
6645 if (temp1)
6646 delete arg1;
6647 }
6648 {
6649 if (temp2)
6650 delete arg2;
6651 }
6652 {
6653 if (temp3)
6654 delete arg3;
6655 }
6656 return resultobj;
6657 fail:
6658 {
6659 if (temp1)
6660 delete arg1;
6661 }
6662 {
6663 if (temp2)
6664 delete arg2;
6665 }
6666 {
6667 if (temp3)
6668 delete arg3;
6669 }
6670 return NULL;
6671 }
6672
6673
6674 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6675 PyObject *resultobj = 0;
6676 bool result;
6677
6678 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6679 {
6680 if (!wxPyCheckForApp()) SWIG_fail;
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 result = (bool)wxColourDisplay();
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 {
6687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6688 }
6689 return resultobj;
6690 fail:
6691 return NULL;
6692 }
6693
6694
6695 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6696 PyObject *resultobj = 0;
6697 int result;
6698
6699 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6700 {
6701 if (!wxPyCheckForApp()) SWIG_fail;
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 result = (int)wxDisplayDepth();
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 resultobj = SWIG_From_int(static_cast< int >(result));
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6715 PyObject *resultobj = 0;
6716 int result;
6717
6718 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6719 {
6720 if (!wxPyCheckForApp()) SWIG_fail;
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 result = (int)wxGetDisplayDepth();
6723 wxPyEndAllowThreads(__tstate);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 resultobj = SWIG_From_int(static_cast< int >(result));
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6734 PyObject *resultobj = 0;
6735 int *arg1 = (int *) 0 ;
6736 int *arg2 = (int *) 0 ;
6737 int temp1 ;
6738 int res1 = SWIG_TMPOBJ ;
6739 int temp2 ;
6740 int res2 = SWIG_TMPOBJ ;
6741
6742 arg1 = &temp1;
6743 arg2 = &temp2;
6744 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6745 {
6746 if (!wxPyCheckForApp()) SWIG_fail;
6747 PyThreadState* __tstate = wxPyBeginAllowThreads();
6748 wxDisplaySize(arg1,arg2);
6749 wxPyEndAllowThreads(__tstate);
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 resultobj = SWIG_Py_Void();
6753 if (SWIG_IsTmpObj(res1)) {
6754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6755 } else {
6756 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6758 }
6759 if (SWIG_IsTmpObj(res2)) {
6760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6761 } else {
6762 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6764 }
6765 return resultobj;
6766 fail:
6767 return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6772 PyObject *resultobj = 0;
6773 wxSize result;
6774
6775 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6776 {
6777 if (!wxPyCheckForApp()) SWIG_fail;
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = wxGetDisplaySize();
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6791 PyObject *resultobj = 0;
6792 int *arg1 = (int *) 0 ;
6793 int *arg2 = (int *) 0 ;
6794 int temp1 ;
6795 int res1 = SWIG_TMPOBJ ;
6796 int temp2 ;
6797 int res2 = SWIG_TMPOBJ ;
6798
6799 arg1 = &temp1;
6800 arg2 = &temp2;
6801 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6802 {
6803 if (!wxPyCheckForApp()) SWIG_fail;
6804 PyThreadState* __tstate = wxPyBeginAllowThreads();
6805 wxDisplaySizeMM(arg1,arg2);
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 resultobj = SWIG_Py_Void();
6810 if (SWIG_IsTmpObj(res1)) {
6811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6812 } else {
6813 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6815 }
6816 if (SWIG_IsTmpObj(res2)) {
6817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6818 } else {
6819 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6821 }
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxSize result;
6831
6832 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6833 {
6834 if (!wxPyCheckForApp()) SWIG_fail;
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 result = wxGetDisplaySizeMM();
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6848 PyObject *resultobj = 0;
6849 int *arg1 = (int *) 0 ;
6850 int *arg2 = (int *) 0 ;
6851 int *arg3 = (int *) 0 ;
6852 int *arg4 = (int *) 0 ;
6853 int temp1 ;
6854 int res1 = SWIG_TMPOBJ ;
6855 int temp2 ;
6856 int res2 = SWIG_TMPOBJ ;
6857 int temp3 ;
6858 int res3 = SWIG_TMPOBJ ;
6859 int temp4 ;
6860 int res4 = SWIG_TMPOBJ ;
6861
6862 arg1 = &temp1;
6863 arg2 = &temp2;
6864 arg3 = &temp3;
6865 arg4 = &temp4;
6866 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6867 {
6868 if (!wxPyCheckForApp()) SWIG_fail;
6869 PyThreadState* __tstate = wxPyBeginAllowThreads();
6870 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 resultobj = SWIG_Py_Void();
6875 if (SWIG_IsTmpObj(res1)) {
6876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6877 } else {
6878 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6880 }
6881 if (SWIG_IsTmpObj(res2)) {
6882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6883 } else {
6884 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6886 }
6887 if (SWIG_IsTmpObj(res3)) {
6888 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6889 } else {
6890 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6892 }
6893 if (SWIG_IsTmpObj(res4)) {
6894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6895 } else {
6896 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6898 }
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6906 PyObject *resultobj = 0;
6907 wxRect result;
6908
6909 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6910 {
6911 if (!wxPyCheckForApp()) SWIG_fail;
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = wxGetClientDisplayRect();
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6925 PyObject *resultobj = 0;
6926 wxCursor *arg1 = 0 ;
6927 void *argp1 = 0 ;
6928 int res1 = 0 ;
6929 PyObject * obj0 = 0 ;
6930 char * kwnames[] = {
6931 (char *) "cursor", NULL
6932 };
6933
6934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6935 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6936 if (!SWIG_IsOK(res1)) {
6937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6938 }
6939 if (!argp1) {
6940 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6941 }
6942 arg1 = reinterpret_cast< wxCursor * >(argp1);
6943 {
6944 if (!wxPyCheckForApp()) SWIG_fail;
6945 PyThreadState* __tstate = wxPyBeginAllowThreads();
6946 wxSetCursor(*arg1);
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_Py_Void();
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6958 PyObject *resultobj = 0;
6959 void *result = 0 ;
6960
6961 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6962 {
6963 if (!wxPyCheckForApp()) SWIG_fail;
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 result = (void *)wxGetXDisplay();
6966 wxPyEndAllowThreads(__tstate);
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6970 return resultobj;
6971 fail:
6972 return NULL;
6973 }
6974
6975
6976 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6977 PyObject *resultobj = 0;
6978 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6979 void *argp1 = 0 ;
6980 int res1 = 0 ;
6981 PyObject * obj0 = 0 ;
6982 char * kwnames[] = {
6983 (char *) "cursor", NULL
6984 };
6985
6986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6987 if (obj0) {
6988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6989 if (!SWIG_IsOK(res1)) {
6990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6991 }
6992 arg1 = reinterpret_cast< wxCursor * >(argp1);
6993 }
6994 {
6995 if (!wxPyCheckForApp()) SWIG_fail;
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 wxBeginBusyCursor(arg1);
6998 wxPyEndAllowThreads(__tstate);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_Py_Void();
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 PyObject *resultobj = 0;
7010 wxPoint result;
7011
7012 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7013 {
7014 if (!wxPyCheckForApp()) SWIG_fail;
7015 PyThreadState* __tstate = wxPyBeginAllowThreads();
7016 result = wxGetMousePosition();
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7028 PyObject *resultobj = 0;
7029 wxWindow *result = 0 ;
7030
7031 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7032 {
7033 if (!wxPyCheckForApp()) SWIG_fail;
7034 PyThreadState* __tstate = wxPyBeginAllowThreads();
7035 result = (wxWindow *)FindWindowAtPointer();
7036 wxPyEndAllowThreads(__tstate);
7037 if (PyErr_Occurred()) SWIG_fail;
7038 }
7039 {
7040 resultobj = wxPyMake_wxObject(result, 0);
7041 }
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7049 PyObject *resultobj = 0;
7050 wxWindow *result = 0 ;
7051
7052 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7053 {
7054 if (!wxPyCheckForApp()) SWIG_fail;
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 result = (wxWindow *)wxGetActiveWindow();
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 {
7061 resultobj = wxPyMake_wxObject(result, 0);
7062 }
7063 return resultobj;
7064 fail:
7065 return NULL;
7066 }
7067
7068
7069 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7070 PyObject *resultobj = 0;
7071 wxPoint *arg1 = 0 ;
7072 wxWindow *result = 0 ;
7073 wxPoint temp1 ;
7074 PyObject * obj0 = 0 ;
7075 char * kwnames[] = {
7076 (char *) "pt", NULL
7077 };
7078
7079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7080 {
7081 arg1 = &temp1;
7082 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7083 }
7084 {
7085 if (!wxPyCheckForApp()) SWIG_fail;
7086 PyThreadState* __tstate = wxPyBeginAllowThreads();
7087 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7088 wxPyEndAllowThreads(__tstate);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 {
7092 resultobj = wxPyMake_wxObject(result, 0);
7093 }
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7101 PyObject *resultobj = 0;
7102 wxPoint *arg1 = 0 ;
7103 wxWindow *result = 0 ;
7104 wxPoint temp1 ;
7105 PyObject * obj0 = 0 ;
7106 char * kwnames[] = {
7107 (char *) "pt", NULL
7108 };
7109
7110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7111 {
7112 arg1 = &temp1;
7113 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7114 }
7115 {
7116 if (!wxPyCheckForApp()) SWIG_fail;
7117 PyThreadState* __tstate = wxPyBeginAllowThreads();
7118 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7119 wxPyEndAllowThreads(__tstate);
7120 if (PyErr_Occurred()) SWIG_fail;
7121 }
7122 {
7123 resultobj = wxPyMake_wxObject(result, 0);
7124 }
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7132 PyObject *resultobj = 0;
7133 wxWindow *arg1 = (wxWindow *) 0 ;
7134 wxWindow *result = 0 ;
7135 void *argp1 = 0 ;
7136 int res1 = 0 ;
7137 PyObject * obj0 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "win", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7146 }
7147 arg1 = reinterpret_cast< wxWindow * >(argp1);
7148 {
7149 if (!wxPyCheckForApp()) SWIG_fail;
7150 PyThreadState* __tstate = wxPyBeginAllowThreads();
7151 result = (wxWindow *)wxGetTopLevelParent(arg1);
7152 wxPyEndAllowThreads(__tstate);
7153 if (PyErr_Occurred()) SWIG_fail;
7154 }
7155 {
7156 resultobj = wxPyMake_wxObject(result, 0);
7157 }
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxString *arg1 = 0 ;
7167 bool result;
7168 bool temp1 = false ;
7169 PyObject * obj0 = 0 ;
7170 char * kwnames[] = {
7171 (char *) "url", NULL
7172 };
7173
7174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7175 {
7176 arg1 = wxString_in_helper(obj0);
7177 if (arg1 == NULL) SWIG_fail;
7178 temp1 = true;
7179 }
7180 {
7181 PyThreadState* __tstate = wxPyBeginAllowThreads();
7182 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 {
7187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7188 }
7189 {
7190 if (temp1)
7191 delete arg1;
7192 }
7193 return resultobj;
7194 fail:
7195 {
7196 if (temp1)
7197 delete arg1;
7198 }
7199 return NULL;
7200 }
7201
7202
7203 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7204 PyObject *resultobj = 0;
7205 wxKeyCode arg1 ;
7206 bool result;
7207 int val1 ;
7208 int ecode1 = 0 ;
7209 PyObject * obj0 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "key", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7215 ecode1 = SWIG_AsVal_int(obj0, &val1);
7216 if (!SWIG_IsOK(ecode1)) {
7217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7218 }
7219 arg1 = static_cast< wxKeyCode >(val1);
7220 {
7221 if (!wxPyCheckForApp()) SWIG_fail;
7222 PyThreadState* __tstate = wxPyBeginAllowThreads();
7223 result = (bool)wxGetKeyState(arg1);
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 {
7228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7229 }
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7237 PyObject *resultobj = 0;
7238 wxMouseState *result = 0 ;
7239
7240 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7241 {
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 result = (wxMouseState *)new wxMouseState();
7244 wxPyEndAllowThreads(__tstate);
7245 if (PyErr_Occurred()) SWIG_fail;
7246 }
7247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7248 return resultobj;
7249 fail:
7250 return NULL;
7251 }
7252
7253
7254 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7255 PyObject *resultobj = 0;
7256 wxMouseState *arg1 = (wxMouseState *) 0 ;
7257 void *argp1 = 0 ;
7258 int res1 = 0 ;
7259 PyObject *swig_obj[1] ;
7260
7261 if (!args) SWIG_fail;
7262 swig_obj[0] = args;
7263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7264 if (!SWIG_IsOK(res1)) {
7265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7266 }
7267 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7268 {
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 delete arg1;
7271
7272 wxPyEndAllowThreads(__tstate);
7273 if (PyErr_Occurred()) SWIG_fail;
7274 }
7275 resultobj = SWIG_Py_Void();
7276 return resultobj;
7277 fail:
7278 return NULL;
7279 }
7280
7281
7282 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7283 PyObject *resultobj = 0;
7284 wxMouseState *arg1 = (wxMouseState *) 0 ;
7285 int result;
7286 void *argp1 = 0 ;
7287 int res1 = 0 ;
7288 PyObject *swig_obj[1] ;
7289
7290 if (!args) SWIG_fail;
7291 swig_obj[0] = args;
7292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7295 }
7296 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7297 {
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 result = (int)(arg1)->GetX();
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 resultobj = SWIG_From_int(static_cast< int >(result));
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7311 PyObject *resultobj = 0;
7312 wxMouseState *arg1 = (wxMouseState *) 0 ;
7313 int result;
7314 void *argp1 = 0 ;
7315 int res1 = 0 ;
7316 PyObject *swig_obj[1] ;
7317
7318 if (!args) SWIG_fail;
7319 swig_obj[0] = args;
7320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7321 if (!SWIG_IsOK(res1)) {
7322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7323 }
7324 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (int)(arg1)->GetY();
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 resultobj = SWIG_From_int(static_cast< int >(result));
7332 return resultobj;
7333 fail:
7334 return NULL;
7335 }
7336
7337
7338 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7339 PyObject *resultobj = 0;
7340 wxMouseState *arg1 = (wxMouseState *) 0 ;
7341 bool result;
7342 void *argp1 = 0 ;
7343 int res1 = 0 ;
7344 PyObject *swig_obj[1] ;
7345
7346 if (!args) SWIG_fail;
7347 swig_obj[0] = args;
7348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7349 if (!SWIG_IsOK(res1)) {
7350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7351 }
7352 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 result = (bool)(arg1)->LeftDown();
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 {
7360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7361 }
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7369 PyObject *resultobj = 0;
7370 wxMouseState *arg1 = (wxMouseState *) 0 ;
7371 bool result;
7372 void *argp1 = 0 ;
7373 int res1 = 0 ;
7374 PyObject *swig_obj[1] ;
7375
7376 if (!args) SWIG_fail;
7377 swig_obj[0] = args;
7378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7379 if (!SWIG_IsOK(res1)) {
7380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7381 }
7382 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7383 {
7384 PyThreadState* __tstate = wxPyBeginAllowThreads();
7385 result = (bool)(arg1)->MiddleDown();
7386 wxPyEndAllowThreads(__tstate);
7387 if (PyErr_Occurred()) SWIG_fail;
7388 }
7389 {
7390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7391 }
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7399 PyObject *resultobj = 0;
7400 wxMouseState *arg1 = (wxMouseState *) 0 ;
7401 bool result;
7402 void *argp1 = 0 ;
7403 int res1 = 0 ;
7404 PyObject *swig_obj[1] ;
7405
7406 if (!args) SWIG_fail;
7407 swig_obj[0] = args;
7408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7409 if (!SWIG_IsOK(res1)) {
7410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7411 }
7412 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 result = (bool)(arg1)->RightDown();
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 {
7420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7421 }
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7429 PyObject *resultobj = 0;
7430 wxMouseState *arg1 = (wxMouseState *) 0 ;
7431 bool result;
7432 void *argp1 = 0 ;
7433 int res1 = 0 ;
7434 PyObject *swig_obj[1] ;
7435
7436 if (!args) SWIG_fail;
7437 swig_obj[0] = args;
7438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7439 if (!SWIG_IsOK(res1)) {
7440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7441 }
7442 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7443 {
7444 PyThreadState* __tstate = wxPyBeginAllowThreads();
7445 result = (bool)(arg1)->ControlDown();
7446 wxPyEndAllowThreads(__tstate);
7447 if (PyErr_Occurred()) SWIG_fail;
7448 }
7449 {
7450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7451 }
7452 return resultobj;
7453 fail:
7454 return NULL;
7455 }
7456
7457
7458 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7459 PyObject *resultobj = 0;
7460 wxMouseState *arg1 = (wxMouseState *) 0 ;
7461 bool result;
7462 void *argp1 = 0 ;
7463 int res1 = 0 ;
7464 PyObject *swig_obj[1] ;
7465
7466 if (!args) SWIG_fail;
7467 swig_obj[0] = args;
7468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7469 if (!SWIG_IsOK(res1)) {
7470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7471 }
7472 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7473 {
7474 PyThreadState* __tstate = wxPyBeginAllowThreads();
7475 result = (bool)(arg1)->ShiftDown();
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 {
7480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7481 }
7482 return resultobj;
7483 fail:
7484 return NULL;
7485 }
7486
7487
7488 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7489 PyObject *resultobj = 0;
7490 wxMouseState *arg1 = (wxMouseState *) 0 ;
7491 bool result;
7492 void *argp1 = 0 ;
7493 int res1 = 0 ;
7494 PyObject *swig_obj[1] ;
7495
7496 if (!args) SWIG_fail;
7497 swig_obj[0] = args;
7498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7501 }
7502 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7503 {
7504 PyThreadState* __tstate = wxPyBeginAllowThreads();
7505 result = (bool)(arg1)->AltDown();
7506 wxPyEndAllowThreads(__tstate);
7507 if (PyErr_Occurred()) SWIG_fail;
7508 }
7509 {
7510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7511 }
7512 return resultobj;
7513 fail:
7514 return NULL;
7515 }
7516
7517
7518 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7519 PyObject *resultobj = 0;
7520 wxMouseState *arg1 = (wxMouseState *) 0 ;
7521 bool result;
7522 void *argp1 = 0 ;
7523 int res1 = 0 ;
7524 PyObject *swig_obj[1] ;
7525
7526 if (!args) SWIG_fail;
7527 swig_obj[0] = args;
7528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7529 if (!SWIG_IsOK(res1)) {
7530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7531 }
7532 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7533 {
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 result = (bool)(arg1)->MetaDown();
7536 wxPyEndAllowThreads(__tstate);
7537 if (PyErr_Occurred()) SWIG_fail;
7538 }
7539 {
7540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7541 }
7542 return resultobj;
7543 fail:
7544 return NULL;
7545 }
7546
7547
7548 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7549 PyObject *resultobj = 0;
7550 wxMouseState *arg1 = (wxMouseState *) 0 ;
7551 bool result;
7552 void *argp1 = 0 ;
7553 int res1 = 0 ;
7554 PyObject *swig_obj[1] ;
7555
7556 if (!args) SWIG_fail;
7557 swig_obj[0] = args;
7558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7561 }
7562 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7563 {
7564 PyThreadState* __tstate = wxPyBeginAllowThreads();
7565 result = (bool)(arg1)->CmdDown();
7566 wxPyEndAllowThreads(__tstate);
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 {
7570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7571 }
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj = 0;
7580 wxMouseState *arg1 = (wxMouseState *) 0 ;
7581 int arg2 ;
7582 void *argp1 = 0 ;
7583 int res1 = 0 ;
7584 int val2 ;
7585 int ecode2 = 0 ;
7586 PyObject * obj0 = 0 ;
7587 PyObject * obj1 = 0 ;
7588 char * kwnames[] = {
7589 (char *) "self",(char *) "x", NULL
7590 };
7591
7592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7594 if (!SWIG_IsOK(res1)) {
7595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7596 }
7597 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7598 ecode2 = SWIG_AsVal_int(obj1, &val2);
7599 if (!SWIG_IsOK(ecode2)) {
7600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7601 }
7602 arg2 = static_cast< int >(val2);
7603 {
7604 PyThreadState* __tstate = wxPyBeginAllowThreads();
7605 (arg1)->SetX(arg2);
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 resultobj = SWIG_Py_Void();
7610 return resultobj;
7611 fail:
7612 return NULL;
7613 }
7614
7615
7616 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7617 PyObject *resultobj = 0;
7618 wxMouseState *arg1 = (wxMouseState *) 0 ;
7619 int arg2 ;
7620 void *argp1 = 0 ;
7621 int res1 = 0 ;
7622 int val2 ;
7623 int ecode2 = 0 ;
7624 PyObject * obj0 = 0 ;
7625 PyObject * obj1 = 0 ;
7626 char * kwnames[] = {
7627 (char *) "self",(char *) "y", NULL
7628 };
7629
7630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7632 if (!SWIG_IsOK(res1)) {
7633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7634 }
7635 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7636 ecode2 = SWIG_AsVal_int(obj1, &val2);
7637 if (!SWIG_IsOK(ecode2)) {
7638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7639 }
7640 arg2 = static_cast< int >(val2);
7641 {
7642 PyThreadState* __tstate = wxPyBeginAllowThreads();
7643 (arg1)->SetY(arg2);
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 resultobj = SWIG_Py_Void();
7648 return resultobj;
7649 fail:
7650 return NULL;
7651 }
7652
7653
7654 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7655 PyObject *resultobj = 0;
7656 wxMouseState *arg1 = (wxMouseState *) 0 ;
7657 bool arg2 ;
7658 void *argp1 = 0 ;
7659 int res1 = 0 ;
7660 bool val2 ;
7661 int ecode2 = 0 ;
7662 PyObject * obj0 = 0 ;
7663 PyObject * obj1 = 0 ;
7664 char * kwnames[] = {
7665 (char *) "self",(char *) "down", NULL
7666 };
7667
7668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7670 if (!SWIG_IsOK(res1)) {
7671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7672 }
7673 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7674 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7675 if (!SWIG_IsOK(ecode2)) {
7676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7677 }
7678 arg2 = static_cast< bool >(val2);
7679 {
7680 PyThreadState* __tstate = wxPyBeginAllowThreads();
7681 (arg1)->SetLeftDown(arg2);
7682 wxPyEndAllowThreads(__tstate);
7683 if (PyErr_Occurred()) SWIG_fail;
7684 }
7685 resultobj = SWIG_Py_Void();
7686 return resultobj;
7687 fail:
7688 return NULL;
7689 }
7690
7691
7692 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7693 PyObject *resultobj = 0;
7694 wxMouseState *arg1 = (wxMouseState *) 0 ;
7695 bool arg2 ;
7696 void *argp1 = 0 ;
7697 int res1 = 0 ;
7698 bool val2 ;
7699 int ecode2 = 0 ;
7700 PyObject * obj0 = 0 ;
7701 PyObject * obj1 = 0 ;
7702 char * kwnames[] = {
7703 (char *) "self",(char *) "down", NULL
7704 };
7705
7706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7708 if (!SWIG_IsOK(res1)) {
7709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7710 }
7711 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7712 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7713 if (!SWIG_IsOK(ecode2)) {
7714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7715 }
7716 arg2 = static_cast< bool >(val2);
7717 {
7718 PyThreadState* __tstate = wxPyBeginAllowThreads();
7719 (arg1)->SetMiddleDown(arg2);
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 resultobj = SWIG_Py_Void();
7724 return resultobj;
7725 fail:
7726 return NULL;
7727 }
7728
7729
7730 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7731 PyObject *resultobj = 0;
7732 wxMouseState *arg1 = (wxMouseState *) 0 ;
7733 bool arg2 ;
7734 void *argp1 = 0 ;
7735 int res1 = 0 ;
7736 bool val2 ;
7737 int ecode2 = 0 ;
7738 PyObject * obj0 = 0 ;
7739 PyObject * obj1 = 0 ;
7740 char * kwnames[] = {
7741 (char *) "self",(char *) "down", NULL
7742 };
7743
7744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7746 if (!SWIG_IsOK(res1)) {
7747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7748 }
7749 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7750 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7751 if (!SWIG_IsOK(ecode2)) {
7752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7753 }
7754 arg2 = static_cast< bool >(val2);
7755 {
7756 PyThreadState* __tstate = wxPyBeginAllowThreads();
7757 (arg1)->SetRightDown(arg2);
7758 wxPyEndAllowThreads(__tstate);
7759 if (PyErr_Occurred()) SWIG_fail;
7760 }
7761 resultobj = SWIG_Py_Void();
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj = 0;
7770 wxMouseState *arg1 = (wxMouseState *) 0 ;
7771 bool arg2 ;
7772 void *argp1 = 0 ;
7773 int res1 = 0 ;
7774 bool val2 ;
7775 int ecode2 = 0 ;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 char * kwnames[] = {
7779 (char *) "self",(char *) "down", NULL
7780 };
7781
7782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7784 if (!SWIG_IsOK(res1)) {
7785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7786 }
7787 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7789 if (!SWIG_IsOK(ecode2)) {
7790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7791 }
7792 arg2 = static_cast< bool >(val2);
7793 {
7794 PyThreadState* __tstate = wxPyBeginAllowThreads();
7795 (arg1)->SetControlDown(arg2);
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 resultobj = SWIG_Py_Void();
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj = 0;
7808 wxMouseState *arg1 = (wxMouseState *) 0 ;
7809 bool arg2 ;
7810 void *argp1 = 0 ;
7811 int res1 = 0 ;
7812 bool val2 ;
7813 int ecode2 = 0 ;
7814 PyObject * obj0 = 0 ;
7815 PyObject * obj1 = 0 ;
7816 char * kwnames[] = {
7817 (char *) "self",(char *) "down", NULL
7818 };
7819
7820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7822 if (!SWIG_IsOK(res1)) {
7823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7824 }
7825 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7826 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7827 if (!SWIG_IsOK(ecode2)) {
7828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7829 }
7830 arg2 = static_cast< bool >(val2);
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 (arg1)->SetShiftDown(arg2);
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 resultobj = SWIG_Py_Void();
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7845 PyObject *resultobj = 0;
7846 wxMouseState *arg1 = (wxMouseState *) 0 ;
7847 bool arg2 ;
7848 void *argp1 = 0 ;
7849 int res1 = 0 ;
7850 bool val2 ;
7851 int ecode2 = 0 ;
7852 PyObject * obj0 = 0 ;
7853 PyObject * obj1 = 0 ;
7854 char * kwnames[] = {
7855 (char *) "self",(char *) "down", NULL
7856 };
7857
7858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7860 if (!SWIG_IsOK(res1)) {
7861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7862 }
7863 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7864 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7865 if (!SWIG_IsOK(ecode2)) {
7866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7867 }
7868 arg2 = static_cast< bool >(val2);
7869 {
7870 PyThreadState* __tstate = wxPyBeginAllowThreads();
7871 (arg1)->SetAltDown(arg2);
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 resultobj = SWIG_Py_Void();
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj = 0;
7884 wxMouseState *arg1 = (wxMouseState *) 0 ;
7885 bool arg2 ;
7886 void *argp1 = 0 ;
7887 int res1 = 0 ;
7888 bool val2 ;
7889 int ecode2 = 0 ;
7890 PyObject * obj0 = 0 ;
7891 PyObject * obj1 = 0 ;
7892 char * kwnames[] = {
7893 (char *) "self",(char *) "down", NULL
7894 };
7895
7896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7898 if (!SWIG_IsOK(res1)) {
7899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7900 }
7901 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7902 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7903 if (!SWIG_IsOK(ecode2)) {
7904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7905 }
7906 arg2 = static_cast< bool >(val2);
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 (arg1)->SetMetaDown(arg2);
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 resultobj = SWIG_Py_Void();
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7921 PyObject *obj;
7922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7923 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7924 return SWIG_Py_Void();
7925 }
7926
7927 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7928 return SWIG_Python_InitShadowInstance(args);
7929 }
7930
7931 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7932 PyObject *resultobj = 0;
7933 wxMouseState result;
7934
7935 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7936 {
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 result = wxGetMouseState();
7939 wxPyEndAllowThreads(__tstate);
7940 if (PyErr_Occurred()) SWIG_fail;
7941 }
7942 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7950 PyObject *resultobj = 0;
7951
7952 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7953 {
7954 if (!wxPyCheckForApp()) SWIG_fail;
7955 PyThreadState* __tstate = wxPyBeginAllowThreads();
7956 wxWakeUpMainThread();
7957 wxPyEndAllowThreads(__tstate);
7958 if (PyErr_Occurred()) SWIG_fail;
7959 }
7960 resultobj = SWIG_Py_Void();
7961 return resultobj;
7962 fail:
7963 return NULL;
7964 }
7965
7966
7967 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7968 PyObject *resultobj = 0;
7969
7970 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7971 {
7972 if (!wxPyCheckForApp()) SWIG_fail;
7973 PyThreadState* __tstate = wxPyBeginAllowThreads();
7974 wxMutexGuiEnter();
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 resultobj = SWIG_Py_Void();
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7986 PyObject *resultobj = 0;
7987
7988 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7989 {
7990 if (!wxPyCheckForApp()) SWIG_fail;
7991 PyThreadState* __tstate = wxPyBeginAllowThreads();
7992 wxMutexGuiLeave();
7993 wxPyEndAllowThreads(__tstate);
7994 if (PyErr_Occurred()) SWIG_fail;
7995 }
7996 resultobj = SWIG_Py_Void();
7997 return resultobj;
7998 fail:
7999 return NULL;
8000 }
8001
8002
8003 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8004 PyObject *resultobj = 0;
8005 wxMutexGuiLocker *result = 0 ;
8006
8007 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8008 {
8009 if (!wxPyCheckForApp()) SWIG_fail;
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *resultobj = 0;
8024 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8025 void *argp1 = 0 ;
8026 int res1 = 0 ;
8027 PyObject *swig_obj[1] ;
8028
8029 if (!args) SWIG_fail;
8030 swig_obj[0] = args;
8031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8032 if (!SWIG_IsOK(res1)) {
8033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8034 }
8035 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8036 {
8037 PyThreadState* __tstate = wxPyBeginAllowThreads();
8038 delete arg1;
8039
8040 wxPyEndAllowThreads(__tstate);
8041 if (PyErr_Occurred()) SWIG_fail;
8042 }
8043 resultobj = SWIG_Py_Void();
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8051 PyObject *obj;
8052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8053 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8054 return SWIG_Py_Void();
8055 }
8056
8057 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8058 return SWIG_Python_InitShadowInstance(args);
8059 }
8060
8061 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8062 PyObject *resultobj = 0;
8063 bool result;
8064
8065 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8066 {
8067 PyThreadState* __tstate = wxPyBeginAllowThreads();
8068 result = (bool)wxThread_IsMain();
8069 wxPyEndAllowThreads(__tstate);
8070 if (PyErr_Occurred()) SWIG_fail;
8071 }
8072 {
8073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8074 }
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8082 PyObject *resultobj = 0;
8083 wxString *arg1 = 0 ;
8084 wxToolTip *result = 0 ;
8085 bool temp1 = false ;
8086 PyObject * obj0 = 0 ;
8087 char * kwnames[] = {
8088 (char *) "tip", NULL
8089 };
8090
8091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8092 {
8093 arg1 = wxString_in_helper(obj0);
8094 if (arg1 == NULL) SWIG_fail;
8095 temp1 = true;
8096 }
8097 {
8098 if (!wxPyCheckForApp()) SWIG_fail;
8099 PyThreadState* __tstate = wxPyBeginAllowThreads();
8100 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8101 wxPyEndAllowThreads(__tstate);
8102 if (PyErr_Occurred()) SWIG_fail;
8103 }
8104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8105 {
8106 if (temp1)
8107 delete arg1;
8108 }
8109 return resultobj;
8110 fail:
8111 {
8112 if (temp1)
8113 delete arg1;
8114 }
8115 return NULL;
8116 }
8117
8118
8119 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8120 PyObject *resultobj = 0;
8121 wxToolTip *arg1 = (wxToolTip *) 0 ;
8122 void *argp1 = 0 ;
8123 int res1 = 0 ;
8124 PyObject *swig_obj[1] ;
8125
8126 if (!args) SWIG_fail;
8127 swig_obj[0] = args;
8128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8129 if (!SWIG_IsOK(res1)) {
8130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8131 }
8132 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 delete arg1;
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj = 0;
8149 wxToolTip *arg1 = (wxToolTip *) 0 ;
8150 wxString *arg2 = 0 ;
8151 void *argp1 = 0 ;
8152 int res1 = 0 ;
8153 bool temp2 = false ;
8154 PyObject * obj0 = 0 ;
8155 PyObject * obj1 = 0 ;
8156 char * kwnames[] = {
8157 (char *) "self",(char *) "tip", NULL
8158 };
8159
8160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8162 if (!SWIG_IsOK(res1)) {
8163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8164 }
8165 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8166 {
8167 arg2 = wxString_in_helper(obj1);
8168 if (arg2 == NULL) SWIG_fail;
8169 temp2 = true;
8170 }
8171 {
8172 PyThreadState* __tstate = wxPyBeginAllowThreads();
8173 (arg1)->SetTip((wxString const &)*arg2);
8174 wxPyEndAllowThreads(__tstate);
8175 if (PyErr_Occurred()) SWIG_fail;
8176 }
8177 resultobj = SWIG_Py_Void();
8178 {
8179 if (temp2)
8180 delete arg2;
8181 }
8182 return resultobj;
8183 fail:
8184 {
8185 if (temp2)
8186 delete arg2;
8187 }
8188 return NULL;
8189 }
8190
8191
8192 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8193 PyObject *resultobj = 0;
8194 wxToolTip *arg1 = (wxToolTip *) 0 ;
8195 wxString result;
8196 void *argp1 = 0 ;
8197 int res1 = 0 ;
8198 PyObject *swig_obj[1] ;
8199
8200 if (!args) SWIG_fail;
8201 swig_obj[0] = args;
8202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8203 if (!SWIG_IsOK(res1)) {
8204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8205 }
8206 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 result = (arg1)->GetTip();
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 {
8214 #if wxUSE_UNICODE
8215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8216 #else
8217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8218 #endif
8219 }
8220 return resultobj;
8221 fail:
8222 return NULL;
8223 }
8224
8225
8226 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8227 PyObject *resultobj = 0;
8228 wxToolTip *arg1 = (wxToolTip *) 0 ;
8229 wxWindow *result = 0 ;
8230 void *argp1 = 0 ;
8231 int res1 = 0 ;
8232 PyObject *swig_obj[1] ;
8233
8234 if (!args) SWIG_fail;
8235 swig_obj[0] = args;
8236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8237 if (!SWIG_IsOK(res1)) {
8238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8239 }
8240 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 result = (wxWindow *)(arg1)->GetWindow();
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 {
8248 resultobj = wxPyMake_wxObject(result, 0);
8249 }
8250 return resultobj;
8251 fail:
8252 return NULL;
8253 }
8254
8255
8256 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8257 PyObject *resultobj = 0;
8258 bool arg1 ;
8259 bool val1 ;
8260 int ecode1 = 0 ;
8261 PyObject * obj0 = 0 ;
8262 char * kwnames[] = {
8263 (char *) "flag", NULL
8264 };
8265
8266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8267 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8268 if (!SWIG_IsOK(ecode1)) {
8269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8270 }
8271 arg1 = static_cast< bool >(val1);
8272 {
8273 PyThreadState* __tstate = wxPyBeginAllowThreads();
8274 wxToolTip::Enable(arg1);
8275 wxPyEndAllowThreads(__tstate);
8276 if (PyErr_Occurred()) SWIG_fail;
8277 }
8278 resultobj = SWIG_Py_Void();
8279 return resultobj;
8280 fail:
8281 return NULL;
8282 }
8283
8284
8285 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8286 PyObject *resultobj = 0;
8287 long arg1 ;
8288 long val1 ;
8289 int ecode1 = 0 ;
8290 PyObject * obj0 = 0 ;
8291 char * kwnames[] = {
8292 (char *) "milliseconds", NULL
8293 };
8294
8295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8296 ecode1 = SWIG_AsVal_long(obj0, &val1);
8297 if (!SWIG_IsOK(ecode1)) {
8298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8299 }
8300 arg1 = static_cast< long >(val1);
8301 {
8302 PyThreadState* __tstate = wxPyBeginAllowThreads();
8303 wxToolTip::SetDelay(arg1);
8304 wxPyEndAllowThreads(__tstate);
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 resultobj = SWIG_Py_Void();
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8315 PyObject *obj;
8316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8317 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8318 return SWIG_Py_Void();
8319 }
8320
8321 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8322 return SWIG_Python_InitShadowInstance(args);
8323 }
8324
8325 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8326 PyObject *resultobj = 0;
8327 wxWindow *arg1 = (wxWindow *) 0 ;
8328 wxSize *arg2 = 0 ;
8329 wxCaret *result = 0 ;
8330 void *argp1 = 0 ;
8331 int res1 = 0 ;
8332 wxSize temp2 ;
8333 PyObject * obj0 = 0 ;
8334 PyObject * obj1 = 0 ;
8335 char * kwnames[] = {
8336 (char *) "window",(char *) "size", NULL
8337 };
8338
8339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8343 }
8344 arg1 = reinterpret_cast< wxWindow * >(argp1);
8345 {
8346 arg2 = &temp2;
8347 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8348 }
8349 {
8350 if (!wxPyCheckForApp()) SWIG_fail;
8351 PyThreadState* __tstate = wxPyBeginAllowThreads();
8352 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8353 wxPyEndAllowThreads(__tstate);
8354 if (PyErr_Occurred()) SWIG_fail;
8355 }
8356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8357 return resultobj;
8358 fail:
8359 return NULL;
8360 }
8361
8362
8363 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8364 PyObject *resultobj = 0;
8365 wxCaret *arg1 = (wxCaret *) 0 ;
8366 void *argp1 = 0 ;
8367 int res1 = 0 ;
8368 PyObject *swig_obj[1] ;
8369
8370 if (!args) SWIG_fail;
8371 swig_obj[0] = args;
8372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8373 if (!SWIG_IsOK(res1)) {
8374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8375 }
8376 arg1 = reinterpret_cast< wxCaret * >(argp1);
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 delete arg1;
8380
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 resultobj = SWIG_Py_Void();
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8392 PyObject *resultobj = 0;
8393 wxCaret *arg1 = (wxCaret *) 0 ;
8394 void *argp1 = 0 ;
8395 int res1 = 0 ;
8396 PyObject *swig_obj[1] ;
8397
8398 if (!args) SWIG_fail;
8399 swig_obj[0] = args;
8400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8401 if (!SWIG_IsOK(res1)) {
8402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8403 }
8404 arg1 = reinterpret_cast< wxCaret * >(argp1);
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 wxCaret_Destroy(arg1);
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_Py_Void();
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8419 PyObject *resultobj = 0;
8420 wxCaret *arg1 = (wxCaret *) 0 ;
8421 bool result;
8422 void *argp1 = 0 ;
8423 int res1 = 0 ;
8424 PyObject *swig_obj[1] ;
8425
8426 if (!args) SWIG_fail;
8427 swig_obj[0] = args;
8428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8431 }
8432 arg1 = reinterpret_cast< wxCaret * >(argp1);
8433 {
8434 PyThreadState* __tstate = wxPyBeginAllowThreads();
8435 result = (bool)(arg1)->IsOk();
8436 wxPyEndAllowThreads(__tstate);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 {
8440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8441 }
8442 return resultobj;
8443 fail:
8444 return NULL;
8445 }
8446
8447
8448 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8449 PyObject *resultobj = 0;
8450 wxCaret *arg1 = (wxCaret *) 0 ;
8451 bool result;
8452 void *argp1 = 0 ;
8453 int res1 = 0 ;
8454 PyObject *swig_obj[1] ;
8455
8456 if (!args) SWIG_fail;
8457 swig_obj[0] = args;
8458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8459 if (!SWIG_IsOK(res1)) {
8460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8461 }
8462 arg1 = reinterpret_cast< wxCaret * >(argp1);
8463 {
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 result = (bool)(arg1)->IsVisible();
8466 wxPyEndAllowThreads(__tstate);
8467 if (PyErr_Occurred()) SWIG_fail;
8468 }
8469 {
8470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8471 }
8472 return resultobj;
8473 fail:
8474 return NULL;
8475 }
8476
8477
8478 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8479 PyObject *resultobj = 0;
8480 wxCaret *arg1 = (wxCaret *) 0 ;
8481 wxPoint result;
8482 void *argp1 = 0 ;
8483 int res1 = 0 ;
8484 PyObject *swig_obj[1] ;
8485
8486 if (!args) SWIG_fail;
8487 swig_obj[0] = args;
8488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8489 if (!SWIG_IsOK(res1)) {
8490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8491 }
8492 arg1 = reinterpret_cast< wxCaret * >(argp1);
8493 {
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 result = (arg1)->GetPosition();
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8500 return resultobj;
8501 fail:
8502 return NULL;
8503 }
8504
8505
8506 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8507 PyObject *resultobj = 0;
8508 wxCaret *arg1 = (wxCaret *) 0 ;
8509 int *arg2 = (int *) 0 ;
8510 int *arg3 = (int *) 0 ;
8511 void *argp1 = 0 ;
8512 int res1 = 0 ;
8513 int temp2 ;
8514 int res2 = SWIG_TMPOBJ ;
8515 int temp3 ;
8516 int res3 = SWIG_TMPOBJ ;
8517 PyObject *swig_obj[1] ;
8518
8519 arg2 = &temp2;
8520 arg3 = &temp3;
8521 if (!args) SWIG_fail;
8522 swig_obj[0] = args;
8523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8526 }
8527 arg1 = reinterpret_cast< wxCaret * >(argp1);
8528 {
8529 PyThreadState* __tstate = wxPyBeginAllowThreads();
8530 (arg1)->GetPosition(arg2,arg3);
8531 wxPyEndAllowThreads(__tstate);
8532 if (PyErr_Occurred()) SWIG_fail;
8533 }
8534 resultobj = SWIG_Py_Void();
8535 if (SWIG_IsTmpObj(res2)) {
8536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8537 } else {
8538 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8540 }
8541 if (SWIG_IsTmpObj(res3)) {
8542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8543 } else {
8544 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8546 }
8547 return resultobj;
8548 fail:
8549 return NULL;
8550 }
8551
8552
8553 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8554 PyObject *resultobj = 0;
8555 wxCaret *arg1 = (wxCaret *) 0 ;
8556 wxSize result;
8557 void *argp1 = 0 ;
8558 int res1 = 0 ;
8559 PyObject *swig_obj[1] ;
8560
8561 if (!args) SWIG_fail;
8562 swig_obj[0] = args;
8563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8564 if (!SWIG_IsOK(res1)) {
8565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8566 }
8567 arg1 = reinterpret_cast< wxCaret * >(argp1);
8568 {
8569 PyThreadState* __tstate = wxPyBeginAllowThreads();
8570 result = (arg1)->GetSize();
8571 wxPyEndAllowThreads(__tstate);
8572 if (PyErr_Occurred()) SWIG_fail;
8573 }
8574 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8575 return resultobj;
8576 fail:
8577 return NULL;
8578 }
8579
8580
8581 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8582 PyObject *resultobj = 0;
8583 wxCaret *arg1 = (wxCaret *) 0 ;
8584 int *arg2 = (int *) 0 ;
8585 int *arg3 = (int *) 0 ;
8586 void *argp1 = 0 ;
8587 int res1 = 0 ;
8588 int temp2 ;
8589 int res2 = SWIG_TMPOBJ ;
8590 int temp3 ;
8591 int res3 = SWIG_TMPOBJ ;
8592 PyObject *swig_obj[1] ;
8593
8594 arg2 = &temp2;
8595 arg3 = &temp3;
8596 if (!args) SWIG_fail;
8597 swig_obj[0] = args;
8598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8599 if (!SWIG_IsOK(res1)) {
8600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8601 }
8602 arg1 = reinterpret_cast< wxCaret * >(argp1);
8603 {
8604 PyThreadState* __tstate = wxPyBeginAllowThreads();
8605 (arg1)->GetSize(arg2,arg3);
8606 wxPyEndAllowThreads(__tstate);
8607 if (PyErr_Occurred()) SWIG_fail;
8608 }
8609 resultobj = SWIG_Py_Void();
8610 if (SWIG_IsTmpObj(res2)) {
8611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8612 } else {
8613 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8615 }
8616 if (SWIG_IsTmpObj(res3)) {
8617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8618 } else {
8619 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8621 }
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8629 PyObject *resultobj = 0;
8630 wxCaret *arg1 = (wxCaret *) 0 ;
8631 wxWindow *result = 0 ;
8632 void *argp1 = 0 ;
8633 int res1 = 0 ;
8634 PyObject *swig_obj[1] ;
8635
8636 if (!args) SWIG_fail;
8637 swig_obj[0] = args;
8638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8639 if (!SWIG_IsOK(res1)) {
8640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8641 }
8642 arg1 = reinterpret_cast< wxCaret * >(argp1);
8643 {
8644 PyThreadState* __tstate = wxPyBeginAllowThreads();
8645 result = (wxWindow *)(arg1)->GetWindow();
8646 wxPyEndAllowThreads(__tstate);
8647 if (PyErr_Occurred()) SWIG_fail;
8648 }
8649 {
8650 resultobj = wxPyMake_wxObject(result, 0);
8651 }
8652 return resultobj;
8653 fail:
8654 return NULL;
8655 }
8656
8657
8658 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8659 PyObject *resultobj = 0;
8660 wxCaret *arg1 = (wxCaret *) 0 ;
8661 int arg2 ;
8662 int arg3 ;
8663 void *argp1 = 0 ;
8664 int res1 = 0 ;
8665 int val2 ;
8666 int ecode2 = 0 ;
8667 int val3 ;
8668 int ecode3 = 0 ;
8669 PyObject * obj0 = 0 ;
8670 PyObject * obj1 = 0 ;
8671 PyObject * obj2 = 0 ;
8672 char * kwnames[] = {
8673 (char *) "self",(char *) "x",(char *) "y", NULL
8674 };
8675
8676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8678 if (!SWIG_IsOK(res1)) {
8679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8680 }
8681 arg1 = reinterpret_cast< wxCaret * >(argp1);
8682 ecode2 = SWIG_AsVal_int(obj1, &val2);
8683 if (!SWIG_IsOK(ecode2)) {
8684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8685 }
8686 arg2 = static_cast< int >(val2);
8687 ecode3 = SWIG_AsVal_int(obj2, &val3);
8688 if (!SWIG_IsOK(ecode3)) {
8689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8690 }
8691 arg3 = static_cast< int >(val3);
8692 {
8693 PyThreadState* __tstate = wxPyBeginAllowThreads();
8694 (arg1)->Move(arg2,arg3);
8695 wxPyEndAllowThreads(__tstate);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 resultobj = SWIG_Py_Void();
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj = 0;
8707 wxCaret *arg1 = (wxCaret *) 0 ;
8708 wxPoint *arg2 = 0 ;
8709 void *argp1 = 0 ;
8710 int res1 = 0 ;
8711 wxPoint temp2 ;
8712 PyObject * obj0 = 0 ;
8713 PyObject * obj1 = 0 ;
8714 char * kwnames[] = {
8715 (char *) "self",(char *) "pt", NULL
8716 };
8717
8718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8720 if (!SWIG_IsOK(res1)) {
8721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8722 }
8723 arg1 = reinterpret_cast< wxCaret * >(argp1);
8724 {
8725 arg2 = &temp2;
8726 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8727 }
8728 {
8729 PyThreadState* __tstate = wxPyBeginAllowThreads();
8730 (arg1)->Move((wxPoint const &)*arg2);
8731 wxPyEndAllowThreads(__tstate);
8732 if (PyErr_Occurred()) SWIG_fail;
8733 }
8734 resultobj = SWIG_Py_Void();
8735 return resultobj;
8736 fail:
8737 return NULL;
8738 }
8739
8740
8741 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8742 PyObject *resultobj = 0;
8743 wxCaret *arg1 = (wxCaret *) 0 ;
8744 int arg2 ;
8745 int arg3 ;
8746 void *argp1 = 0 ;
8747 int res1 = 0 ;
8748 int val2 ;
8749 int ecode2 = 0 ;
8750 int val3 ;
8751 int ecode3 = 0 ;
8752 PyObject * obj0 = 0 ;
8753 PyObject * obj1 = 0 ;
8754 PyObject * obj2 = 0 ;
8755 char * kwnames[] = {
8756 (char *) "self",(char *) "width",(char *) "height", NULL
8757 };
8758
8759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8761 if (!SWIG_IsOK(res1)) {
8762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8763 }
8764 arg1 = reinterpret_cast< wxCaret * >(argp1);
8765 ecode2 = SWIG_AsVal_int(obj1, &val2);
8766 if (!SWIG_IsOK(ecode2)) {
8767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8768 }
8769 arg2 = static_cast< int >(val2);
8770 ecode3 = SWIG_AsVal_int(obj2, &val3);
8771 if (!SWIG_IsOK(ecode3)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8773 }
8774 arg3 = static_cast< int >(val3);
8775 {
8776 PyThreadState* __tstate = wxPyBeginAllowThreads();
8777 (arg1)->SetSize(arg2,arg3);
8778 wxPyEndAllowThreads(__tstate);
8779 if (PyErr_Occurred()) SWIG_fail;
8780 }
8781 resultobj = SWIG_Py_Void();
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj = 0;
8790 wxCaret *arg1 = (wxCaret *) 0 ;
8791 wxSize *arg2 = 0 ;
8792 void *argp1 = 0 ;
8793 int res1 = 0 ;
8794 wxSize temp2 ;
8795 PyObject * obj0 = 0 ;
8796 PyObject * obj1 = 0 ;
8797 char * kwnames[] = {
8798 (char *) "self",(char *) "size", NULL
8799 };
8800
8801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8803 if (!SWIG_IsOK(res1)) {
8804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8805 }
8806 arg1 = reinterpret_cast< wxCaret * >(argp1);
8807 {
8808 arg2 = &temp2;
8809 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8810 }
8811 {
8812 PyThreadState* __tstate = wxPyBeginAllowThreads();
8813 (arg1)->SetSize((wxSize const &)*arg2);
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 resultobj = SWIG_Py_Void();
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8825 PyObject *resultobj = 0;
8826 wxCaret *arg1 = (wxCaret *) 0 ;
8827 int arg2 = (int) true ;
8828 void *argp1 = 0 ;
8829 int res1 = 0 ;
8830 int val2 ;
8831 int ecode2 = 0 ;
8832 PyObject * obj0 = 0 ;
8833 PyObject * obj1 = 0 ;
8834 char * kwnames[] = {
8835 (char *) "self",(char *) "show", NULL
8836 };
8837
8838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8840 if (!SWIG_IsOK(res1)) {
8841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8842 }
8843 arg1 = reinterpret_cast< wxCaret * >(argp1);
8844 if (obj1) {
8845 ecode2 = SWIG_AsVal_int(obj1, &val2);
8846 if (!SWIG_IsOK(ecode2)) {
8847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8848 }
8849 arg2 = static_cast< int >(val2);
8850 }
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 (arg1)->Show(arg2);
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 resultobj = SWIG_Py_Void();
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8865 PyObject *resultobj = 0;
8866 wxCaret *arg1 = (wxCaret *) 0 ;
8867 void *argp1 = 0 ;
8868 int res1 = 0 ;
8869 PyObject *swig_obj[1] ;
8870
8871 if (!args) SWIG_fail;
8872 swig_obj[0] = args;
8873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8874 if (!SWIG_IsOK(res1)) {
8875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8876 }
8877 arg1 = reinterpret_cast< wxCaret * >(argp1);
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 (arg1)->Hide();
8881 wxPyEndAllowThreads(__tstate);
8882 if (PyErr_Occurred()) SWIG_fail;
8883 }
8884 resultobj = SWIG_Py_Void();
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8892 PyObject *resultobj = 0;
8893 int result;
8894
8895 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8896 {
8897 PyThreadState* __tstate = wxPyBeginAllowThreads();
8898 result = (int)wxCaret::GetBlinkTime();
8899 wxPyEndAllowThreads(__tstate);
8900 if (PyErr_Occurred()) SWIG_fail;
8901 }
8902 resultobj = SWIG_From_int(static_cast< int >(result));
8903 return resultobj;
8904 fail:
8905 return NULL;
8906 }
8907
8908
8909 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8910 PyObject *resultobj = 0;
8911 int arg1 ;
8912 int val1 ;
8913 int ecode1 = 0 ;
8914 PyObject * obj0 = 0 ;
8915 char * kwnames[] = {
8916 (char *) "milliseconds", NULL
8917 };
8918
8919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8920 ecode1 = SWIG_AsVal_int(obj0, &val1);
8921 if (!SWIG_IsOK(ecode1)) {
8922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8923 }
8924 arg1 = static_cast< int >(val1);
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 wxCaret::SetBlinkTime(arg1);
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 resultobj = SWIG_Py_Void();
8932 return resultobj;
8933 fail:
8934 return NULL;
8935 }
8936
8937
8938 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8939 PyObject *obj;
8940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8941 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8942 return SWIG_Py_Void();
8943 }
8944
8945 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8946 return SWIG_Python_InitShadowInstance(args);
8947 }
8948
8949 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8950 PyObject *resultobj = 0;
8951 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8952 wxBusyCursor *result = 0 ;
8953 void *argp1 = 0 ;
8954 int res1 = 0 ;
8955 PyObject * obj0 = 0 ;
8956 char * kwnames[] = {
8957 (char *) "cursor", NULL
8958 };
8959
8960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8961 if (obj0) {
8962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8963 if (!SWIG_IsOK(res1)) {
8964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8965 }
8966 arg1 = reinterpret_cast< wxCursor * >(argp1);
8967 }
8968 {
8969 if (!wxPyCheckForApp()) SWIG_fail;
8970 PyThreadState* __tstate = wxPyBeginAllowThreads();
8971 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8972 wxPyEndAllowThreads(__tstate);
8973 if (PyErr_Occurred()) SWIG_fail;
8974 }
8975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8976 return resultobj;
8977 fail:
8978 return NULL;
8979 }
8980
8981
8982 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8983 PyObject *resultobj = 0;
8984 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8985 void *argp1 = 0 ;
8986 int res1 = 0 ;
8987 PyObject *swig_obj[1] ;
8988
8989 if (!args) SWIG_fail;
8990 swig_obj[0] = args;
8991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8992 if (!SWIG_IsOK(res1)) {
8993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8994 }
8995 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 delete arg1;
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 resultobj = SWIG_Py_Void();
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9011 PyObject *obj;
9012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9013 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9014 return SWIG_Py_Void();
9015 }
9016
9017 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9018 return SWIG_Python_InitShadowInstance(args);
9019 }
9020
9021 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9022 PyObject *resultobj = 0;
9023 wxWindow *arg1 = (wxWindow *) NULL ;
9024 wxWindowDisabler *result = 0 ;
9025 void *argp1 = 0 ;
9026 int res1 = 0 ;
9027 PyObject * obj0 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "winToSkip", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9033 if (obj0) {
9034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9035 if (!SWIG_IsOK(res1)) {
9036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9037 }
9038 arg1 = reinterpret_cast< wxWindow * >(argp1);
9039 }
9040 {
9041 if (!wxPyCheckForApp()) SWIG_fail;
9042 PyThreadState* __tstate = wxPyBeginAllowThreads();
9043 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9044 wxPyEndAllowThreads(__tstate);
9045 if (PyErr_Occurred()) SWIG_fail;
9046 }
9047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9048 return resultobj;
9049 fail:
9050 return NULL;
9051 }
9052
9053
9054 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9055 PyObject *resultobj = 0;
9056 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9057 void *argp1 = 0 ;
9058 int res1 = 0 ;
9059 PyObject *swig_obj[1] ;
9060
9061 if (!args) SWIG_fail;
9062 swig_obj[0] = args;
9063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9064 if (!SWIG_IsOK(res1)) {
9065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9066 }
9067 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 delete arg1;
9071
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 resultobj = SWIG_Py_Void();
9076 return resultobj;
9077 fail:
9078 return NULL;
9079 }
9080
9081
9082 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9083 PyObject *obj;
9084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9085 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9086 return SWIG_Py_Void();
9087 }
9088
9089 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9090 return SWIG_Python_InitShadowInstance(args);
9091 }
9092
9093 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9094 PyObject *resultobj = 0;
9095 wxString *arg1 = 0 ;
9096 wxBusyInfo *result = 0 ;
9097 bool temp1 = false ;
9098 PyObject * obj0 = 0 ;
9099 char * kwnames[] = {
9100 (char *) "message", NULL
9101 };
9102
9103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9104 {
9105 arg1 = wxString_in_helper(obj0);
9106 if (arg1 == NULL) SWIG_fail;
9107 temp1 = true;
9108 }
9109 {
9110 if (!wxPyCheckForApp()) SWIG_fail;
9111 PyThreadState* __tstate = wxPyBeginAllowThreads();
9112 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9113 wxPyEndAllowThreads(__tstate);
9114 if (PyErr_Occurred()) SWIG_fail;
9115 }
9116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9117 {
9118 if (temp1)
9119 delete arg1;
9120 }
9121 return resultobj;
9122 fail:
9123 {
9124 if (temp1)
9125 delete arg1;
9126 }
9127 return NULL;
9128 }
9129
9130
9131 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9132 PyObject *resultobj = 0;
9133 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 PyObject *swig_obj[1] ;
9137
9138 if (!args) SWIG_fail;
9139 swig_obj[0] = args;
9140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9143 }
9144 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 delete arg1;
9148
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 resultobj = SWIG_Py_Void();
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9160 PyObject *obj;
9161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9162 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9163 return SWIG_Py_Void();
9164 }
9165
9166 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9167 return SWIG_Python_InitShadowInstance(args);
9168 }
9169
9170 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9171 PyObject *resultobj = 0;
9172 wxStopWatch *result = 0 ;
9173
9174 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9175 {
9176 PyThreadState* __tstate = wxPyBeginAllowThreads();
9177 result = (wxStopWatch *)new wxStopWatch();
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9189 PyObject *resultobj = 0;
9190 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9191 long arg2 = (long) 0 ;
9192 void *argp1 = 0 ;
9193 int res1 = 0 ;
9194 long val2 ;
9195 int ecode2 = 0 ;
9196 PyObject * obj0 = 0 ;
9197 PyObject * obj1 = 0 ;
9198 char * kwnames[] = {
9199 (char *) "self",(char *) "t0", NULL
9200 };
9201
9202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9204 if (!SWIG_IsOK(res1)) {
9205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9206 }
9207 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9208 if (obj1) {
9209 ecode2 = SWIG_AsVal_long(obj1, &val2);
9210 if (!SWIG_IsOK(ecode2)) {
9211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9212 }
9213 arg2 = static_cast< long >(val2);
9214 }
9215 {
9216 PyThreadState* __tstate = wxPyBeginAllowThreads();
9217 (arg1)->Start(arg2);
9218 wxPyEndAllowThreads(__tstate);
9219 if (PyErr_Occurred()) SWIG_fail;
9220 }
9221 resultobj = SWIG_Py_Void();
9222 return resultobj;
9223 fail:
9224 return NULL;
9225 }
9226
9227
9228 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9229 PyObject *resultobj = 0;
9230 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9231 void *argp1 = 0 ;
9232 int res1 = 0 ;
9233 PyObject *swig_obj[1] ;
9234
9235 if (!args) SWIG_fail;
9236 swig_obj[0] = args;
9237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9238 if (!SWIG_IsOK(res1)) {
9239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9240 }
9241 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9242 {
9243 PyThreadState* __tstate = wxPyBeginAllowThreads();
9244 (arg1)->Pause();
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 resultobj = SWIG_Py_Void();
9249 return resultobj;
9250 fail:
9251 return NULL;
9252 }
9253
9254
9255 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9256 PyObject *resultobj = 0;
9257 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9258 void *argp1 = 0 ;
9259 int res1 = 0 ;
9260 PyObject *swig_obj[1] ;
9261
9262 if (!args) SWIG_fail;
9263 swig_obj[0] = args;
9264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9265 if (!SWIG_IsOK(res1)) {
9266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9267 }
9268 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 (arg1)->Resume();
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = SWIG_Py_Void();
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283 PyObject *resultobj = 0;
9284 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9285 long result;
9286 void *argp1 = 0 ;
9287 int res1 = 0 ;
9288 PyObject *swig_obj[1] ;
9289
9290 if (!args) SWIG_fail;
9291 swig_obj[0] = args;
9292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9293 if (!SWIG_IsOK(res1)) {
9294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9295 }
9296 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9297 {
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 result = (long)((wxStopWatch const *)arg1)->Time();
9300 wxPyEndAllowThreads(__tstate);
9301 if (PyErr_Occurred()) SWIG_fail;
9302 }
9303 resultobj = SWIG_From_long(static_cast< long >(result));
9304 return resultobj;
9305 fail:
9306 return NULL;
9307 }
9308
9309
9310 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9311 PyObject *obj;
9312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9313 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9314 return SWIG_Py_Void();
9315 }
9316
9317 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9318 return SWIG_Python_InitShadowInstance(args);
9319 }
9320
9321 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9322 PyObject *resultobj = 0;
9323 int arg1 = (int) 9 ;
9324 int arg2 = (int) wxID_FILE1 ;
9325 wxFileHistory *result = 0 ;
9326 int val1 ;
9327 int ecode1 = 0 ;
9328 int val2 ;
9329 int ecode2 = 0 ;
9330 PyObject * obj0 = 0 ;
9331 PyObject * obj1 = 0 ;
9332 char * kwnames[] = {
9333 (char *) "maxFiles",(char *) "idBase", NULL
9334 };
9335
9336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9337 if (obj0) {
9338 ecode1 = SWIG_AsVal_int(obj0, &val1);
9339 if (!SWIG_IsOK(ecode1)) {
9340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9341 }
9342 arg1 = static_cast< int >(val1);
9343 }
9344 if (obj1) {
9345 ecode2 = SWIG_AsVal_int(obj1, &val2);
9346 if (!SWIG_IsOK(ecode2)) {
9347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9348 }
9349 arg2 = static_cast< int >(val2);
9350 }
9351 {
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9354 wxPyEndAllowThreads(__tstate);
9355 if (PyErr_Occurred()) SWIG_fail;
9356 }
9357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9365 PyObject *resultobj = 0;
9366 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 PyObject *swig_obj[1] ;
9370
9371 if (!args) SWIG_fail;
9372 swig_obj[0] = args;
9373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9374 if (!SWIG_IsOK(res1)) {
9375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9376 }
9377 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9378 {
9379 PyThreadState* __tstate = wxPyBeginAllowThreads();
9380 delete arg1;
9381
9382 wxPyEndAllowThreads(__tstate);
9383 if (PyErr_Occurred()) SWIG_fail;
9384 }
9385 resultobj = SWIG_Py_Void();
9386 return resultobj;
9387 fail:
9388 return NULL;
9389 }
9390
9391
9392 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9393 PyObject *resultobj = 0;
9394 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9395 wxString *arg2 = 0 ;
9396 void *argp1 = 0 ;
9397 int res1 = 0 ;
9398 bool temp2 = false ;
9399 PyObject * obj0 = 0 ;
9400 PyObject * obj1 = 0 ;
9401 char * kwnames[] = {
9402 (char *) "self",(char *) "file", NULL
9403 };
9404
9405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9407 if (!SWIG_IsOK(res1)) {
9408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9409 }
9410 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9411 {
9412 arg2 = wxString_in_helper(obj1);
9413 if (arg2 == NULL) SWIG_fail;
9414 temp2 = true;
9415 }
9416 {
9417 PyThreadState* __tstate = wxPyBeginAllowThreads();
9418 (arg1)->AddFileToHistory((wxString const &)*arg2);
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 resultobj = SWIG_Py_Void();
9423 {
9424 if (temp2)
9425 delete arg2;
9426 }
9427 return resultobj;
9428 fail:
9429 {
9430 if (temp2)
9431 delete arg2;
9432 }
9433 return NULL;
9434 }
9435
9436
9437 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj = 0;
9439 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9440 int arg2 ;
9441 void *argp1 = 0 ;
9442 int res1 = 0 ;
9443 int val2 ;
9444 int ecode2 = 0 ;
9445 PyObject * obj0 = 0 ;
9446 PyObject * obj1 = 0 ;
9447 char * kwnames[] = {
9448 (char *) "self",(char *) "i", NULL
9449 };
9450
9451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9453 if (!SWIG_IsOK(res1)) {
9454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9455 }
9456 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9457 ecode2 = SWIG_AsVal_int(obj1, &val2);
9458 if (!SWIG_IsOK(ecode2)) {
9459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9460 }
9461 arg2 = static_cast< int >(val2);
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 (arg1)->RemoveFileFromHistory(arg2);
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 resultobj = SWIG_Py_Void();
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9476 PyObject *resultobj = 0;
9477 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9478 int result;
9479 void *argp1 = 0 ;
9480 int res1 = 0 ;
9481 PyObject *swig_obj[1] ;
9482
9483 if (!args) SWIG_fail;
9484 swig_obj[0] = args;
9485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9486 if (!SWIG_IsOK(res1)) {
9487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9488 }
9489 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9490 {
9491 PyThreadState* __tstate = wxPyBeginAllowThreads();
9492 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9493 wxPyEndAllowThreads(__tstate);
9494 if (PyErr_Occurred()) SWIG_fail;
9495 }
9496 resultobj = SWIG_From_int(static_cast< int >(result));
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9504 PyObject *resultobj = 0;
9505 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9506 wxMenu *arg2 = (wxMenu *) 0 ;
9507 void *argp1 = 0 ;
9508 int res1 = 0 ;
9509 void *argp2 = 0 ;
9510 int res2 = 0 ;
9511 PyObject * obj0 = 0 ;
9512 PyObject * obj1 = 0 ;
9513 char * kwnames[] = {
9514 (char *) "self",(char *) "menu", NULL
9515 };
9516
9517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9519 if (!SWIG_IsOK(res1)) {
9520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9521 }
9522 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9524 if (!SWIG_IsOK(res2)) {
9525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9526 }
9527 arg2 = reinterpret_cast< wxMenu * >(argp2);
9528 {
9529 PyThreadState* __tstate = wxPyBeginAllowThreads();
9530 (arg1)->UseMenu(arg2);
9531 wxPyEndAllowThreads(__tstate);
9532 if (PyErr_Occurred()) SWIG_fail;
9533 }
9534 resultobj = SWIG_Py_Void();
9535 return resultobj;
9536 fail:
9537 return NULL;
9538 }
9539
9540
9541 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9542 PyObject *resultobj = 0;
9543 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9544 wxMenu *arg2 = (wxMenu *) 0 ;
9545 void *argp1 = 0 ;
9546 int res1 = 0 ;
9547 void *argp2 = 0 ;
9548 int res2 = 0 ;
9549 PyObject * obj0 = 0 ;
9550 PyObject * obj1 = 0 ;
9551 char * kwnames[] = {
9552 (char *) "self",(char *) "menu", NULL
9553 };
9554
9555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9557 if (!SWIG_IsOK(res1)) {
9558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9559 }
9560 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9562 if (!SWIG_IsOK(res2)) {
9563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9564 }
9565 arg2 = reinterpret_cast< wxMenu * >(argp2);
9566 {
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 (arg1)->RemoveMenu(arg2);
9569 wxPyEndAllowThreads(__tstate);
9570 if (PyErr_Occurred()) SWIG_fail;
9571 }
9572 resultobj = SWIG_Py_Void();
9573 return resultobj;
9574 fail:
9575 return NULL;
9576 }
9577
9578
9579 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9580 PyObject *resultobj = 0;
9581 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9582 wxConfigBase *arg2 = 0 ;
9583 void *argp1 = 0 ;
9584 int res1 = 0 ;
9585 void *argp2 = 0 ;
9586 int res2 = 0 ;
9587 PyObject * obj0 = 0 ;
9588 PyObject * obj1 = 0 ;
9589 char * kwnames[] = {
9590 (char *) "self",(char *) "config", NULL
9591 };
9592
9593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9595 if (!SWIG_IsOK(res1)) {
9596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9597 }
9598 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9599 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9600 if (!SWIG_IsOK(res2)) {
9601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9602 }
9603 if (!argp2) {
9604 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9605 }
9606 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 (arg1)->Load(*arg2);
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 resultobj = SWIG_Py_Void();
9614 return resultobj;
9615 fail:
9616 return NULL;
9617 }
9618
9619
9620 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9621 PyObject *resultobj = 0;
9622 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9623 wxConfigBase *arg2 = 0 ;
9624 void *argp1 = 0 ;
9625 int res1 = 0 ;
9626 void *argp2 = 0 ;
9627 int res2 = 0 ;
9628 PyObject * obj0 = 0 ;
9629 PyObject * obj1 = 0 ;
9630 char * kwnames[] = {
9631 (char *) "self",(char *) "config", NULL
9632 };
9633
9634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9636 if (!SWIG_IsOK(res1)) {
9637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9638 }
9639 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9640 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9641 if (!SWIG_IsOK(res2)) {
9642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9643 }
9644 if (!argp2) {
9645 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9646 }
9647 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 (arg1)->Save(*arg2);
9651 wxPyEndAllowThreads(__tstate);
9652 if (PyErr_Occurred()) SWIG_fail;
9653 }
9654 resultobj = SWIG_Py_Void();
9655 return resultobj;
9656 fail:
9657 return NULL;
9658 }
9659
9660
9661 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9662 PyObject *resultobj = 0;
9663 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9664 void *argp1 = 0 ;
9665 int res1 = 0 ;
9666 PyObject *swig_obj[1] ;
9667
9668 if (!args) SWIG_fail;
9669 swig_obj[0] = args;
9670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9671 if (!SWIG_IsOK(res1)) {
9672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9673 }
9674 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9675 {
9676 PyThreadState* __tstate = wxPyBeginAllowThreads();
9677 (arg1)->AddFilesToMenu();
9678 wxPyEndAllowThreads(__tstate);
9679 if (PyErr_Occurred()) SWIG_fail;
9680 }
9681 resultobj = SWIG_Py_Void();
9682 return resultobj;
9683 fail:
9684 return NULL;
9685 }
9686
9687
9688 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9689 PyObject *resultobj = 0;
9690 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9691 wxMenu *arg2 = (wxMenu *) 0 ;
9692 void *argp1 = 0 ;
9693 int res1 = 0 ;
9694 void *argp2 = 0 ;
9695 int res2 = 0 ;
9696 PyObject * obj0 = 0 ;
9697 PyObject * obj1 = 0 ;
9698 char * kwnames[] = {
9699 (char *) "self",(char *) "menu", NULL
9700 };
9701
9702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9704 if (!SWIG_IsOK(res1)) {
9705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9706 }
9707 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9709 if (!SWIG_IsOK(res2)) {
9710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9711 }
9712 arg2 = reinterpret_cast< wxMenu * >(argp2);
9713 {
9714 PyThreadState* __tstate = wxPyBeginAllowThreads();
9715 (arg1)->AddFilesToMenu(arg2);
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 resultobj = SWIG_Py_Void();
9720 return resultobj;
9721 fail:
9722 return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9727 PyObject *resultobj = 0;
9728 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9729 int arg2 ;
9730 wxString result;
9731 void *argp1 = 0 ;
9732 int res1 = 0 ;
9733 int val2 ;
9734 int ecode2 = 0 ;
9735 PyObject * obj0 = 0 ;
9736 PyObject * obj1 = 0 ;
9737 char * kwnames[] = {
9738 (char *) "self",(char *) "i", NULL
9739 };
9740
9741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9743 if (!SWIG_IsOK(res1)) {
9744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9745 }
9746 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9747 ecode2 = SWIG_AsVal_int(obj1, &val2);
9748 if (!SWIG_IsOK(ecode2)) {
9749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9750 }
9751 arg2 = static_cast< int >(val2);
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9755 wxPyEndAllowThreads(__tstate);
9756 if (PyErr_Occurred()) SWIG_fail;
9757 }
9758 {
9759 #if wxUSE_UNICODE
9760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9761 #else
9762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9763 #endif
9764 }
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9772 PyObject *resultobj = 0;
9773 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9774 int result;
9775 void *argp1 = 0 ;
9776 int res1 = 0 ;
9777 PyObject *swig_obj[1] ;
9778
9779 if (!args) SWIG_fail;
9780 swig_obj[0] = args;
9781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9782 if (!SWIG_IsOK(res1)) {
9783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9784 }
9785 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 result = (int)((wxFileHistory const *)arg1)->GetCount();
9789 wxPyEndAllowThreads(__tstate);
9790 if (PyErr_Occurred()) SWIG_fail;
9791 }
9792 resultobj = SWIG_From_int(static_cast< int >(result));
9793 return resultobj;
9794 fail:
9795 return NULL;
9796 }
9797
9798
9799 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9800 PyObject *obj;
9801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9802 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9803 return SWIG_Py_Void();
9804 }
9805
9806 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 return SWIG_Python_InitShadowInstance(args);
9808 }
9809
9810 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9811 PyObject *resultobj = 0;
9812 wxString *arg1 = 0 ;
9813 wxString const &arg2_defvalue = wxPyEmptyString ;
9814 wxString *arg2 = (wxString *) &arg2_defvalue ;
9815 wxSingleInstanceChecker *result = 0 ;
9816 bool temp1 = false ;
9817 bool temp2 = false ;
9818 PyObject * obj0 = 0 ;
9819 PyObject * obj1 = 0 ;
9820 char * kwnames[] = {
9821 (char *) "name",(char *) "path", NULL
9822 };
9823
9824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9825 {
9826 arg1 = wxString_in_helper(obj0);
9827 if (arg1 == NULL) SWIG_fail;
9828 temp1 = true;
9829 }
9830 if (obj1) {
9831 {
9832 arg2 = wxString_in_helper(obj1);
9833 if (arg2 == NULL) SWIG_fail;
9834 temp2 = true;
9835 }
9836 }
9837 {
9838 PyThreadState* __tstate = wxPyBeginAllowThreads();
9839 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9844 {
9845 if (temp1)
9846 delete arg1;
9847 }
9848 {
9849 if (temp2)
9850 delete arg2;
9851 }
9852 return resultobj;
9853 fail:
9854 {
9855 if (temp1)
9856 delete arg1;
9857 }
9858 {
9859 if (temp2)
9860 delete arg2;
9861 }
9862 return NULL;
9863 }
9864
9865
9866 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 PyObject *resultobj = 0;
9868 wxSingleInstanceChecker *result = 0 ;
9869
9870 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9871 {
9872 PyThreadState* __tstate = wxPyBeginAllowThreads();
9873 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9878 return resultobj;
9879 fail:
9880 return NULL;
9881 }
9882
9883
9884 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9885 PyObject *resultobj = 0;
9886 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9887 void *argp1 = 0 ;
9888 int res1 = 0 ;
9889 PyObject *swig_obj[1] ;
9890
9891 if (!args) SWIG_fail;
9892 swig_obj[0] = args;
9893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9894 if (!SWIG_IsOK(res1)) {
9895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9896 }
9897 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9898 {
9899 PyThreadState* __tstate = wxPyBeginAllowThreads();
9900 delete arg1;
9901
9902 wxPyEndAllowThreads(__tstate);
9903 if (PyErr_Occurred()) SWIG_fail;
9904 }
9905 resultobj = SWIG_Py_Void();
9906 return resultobj;
9907 fail:
9908 return NULL;
9909 }
9910
9911
9912 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9913 PyObject *resultobj = 0;
9914 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9915 wxString *arg2 = 0 ;
9916 wxString const &arg3_defvalue = wxPyEmptyString ;
9917 wxString *arg3 = (wxString *) &arg3_defvalue ;
9918 bool result;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 bool temp2 = false ;
9922 bool temp3 = false ;
9923 PyObject * obj0 = 0 ;
9924 PyObject * obj1 = 0 ;
9925 PyObject * obj2 = 0 ;
9926 char * kwnames[] = {
9927 (char *) "self",(char *) "name",(char *) "path", NULL
9928 };
9929
9930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9932 if (!SWIG_IsOK(res1)) {
9933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9934 }
9935 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9936 {
9937 arg2 = wxString_in_helper(obj1);
9938 if (arg2 == NULL) SWIG_fail;
9939 temp2 = true;
9940 }
9941 if (obj2) {
9942 {
9943 arg3 = wxString_in_helper(obj2);
9944 if (arg3 == NULL) SWIG_fail;
9945 temp3 = true;
9946 }
9947 }
9948 {
9949 PyThreadState* __tstate = wxPyBeginAllowThreads();
9950 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 {
9955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9956 }
9957 {
9958 if (temp2)
9959 delete arg2;
9960 }
9961 {
9962 if (temp3)
9963 delete arg3;
9964 }
9965 return resultobj;
9966 fail:
9967 {
9968 if (temp2)
9969 delete arg2;
9970 }
9971 {
9972 if (temp3)
9973 delete arg3;
9974 }
9975 return NULL;
9976 }
9977
9978
9979 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9980 PyObject *resultobj = 0;
9981 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9982 bool result;
9983 void *argp1 = 0 ;
9984 int res1 = 0 ;
9985 PyObject *swig_obj[1] ;
9986
9987 if (!args) SWIG_fail;
9988 swig_obj[0] = args;
9989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9992 }
9993 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9994 {
9995 PyThreadState* __tstate = wxPyBeginAllowThreads();
9996 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9997 wxPyEndAllowThreads(__tstate);
9998 if (PyErr_Occurred()) SWIG_fail;
9999 }
10000 {
10001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10002 }
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10010 PyObject *obj;
10011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10012 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10013 return SWIG_Py_Void();
10014 }
10015
10016 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10017 return SWIG_Python_InitShadowInstance(args);
10018 }
10019
10020 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10021 PyObject *resultobj = 0;
10022 wxWindow *arg1 = (wxWindow *) 0 ;
10023 wxDC *arg2 = 0 ;
10024 bool result;
10025 void *argp1 = 0 ;
10026 int res1 = 0 ;
10027 void *argp2 = 0 ;
10028 int res2 = 0 ;
10029 PyObject * obj0 = 0 ;
10030 PyObject * obj1 = 0 ;
10031 char * kwnames[] = {
10032 (char *) "window",(char *) "dc", NULL
10033 };
10034
10035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10037 if (!SWIG_IsOK(res1)) {
10038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10039 }
10040 arg1 = reinterpret_cast< wxWindow * >(argp1);
10041 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10042 if (!SWIG_IsOK(res2)) {
10043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10044 }
10045 if (!argp2) {
10046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10047 }
10048 arg2 = reinterpret_cast< wxDC * >(argp2);
10049 {
10050 PyThreadState* __tstate = wxPyBeginAllowThreads();
10051 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10052 wxPyEndAllowThreads(__tstate);
10053 if (PyErr_Occurred()) SWIG_fail;
10054 }
10055 {
10056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10057 }
10058 return resultobj;
10059 fail:
10060 return NULL;
10061 }
10062
10063
10064 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10065 PyObject *resultobj = 0;
10066 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10067 void *argp1 = 0 ;
10068 int res1 = 0 ;
10069 PyObject *swig_obj[1] ;
10070
10071 if (!args) SWIG_fail;
10072 swig_obj[0] = args;
10073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10074 if (!SWIG_IsOK(res1)) {
10075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10076 }
10077 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 delete arg1;
10081
10082 wxPyEndAllowThreads(__tstate);
10083 if (PyErr_Occurred()) SWIG_fail;
10084 }
10085 resultobj = SWIG_Py_Void();
10086 return resultobj;
10087 fail:
10088 return NULL;
10089 }
10090
10091
10092 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10093 PyObject *resultobj = 0;
10094 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10095 wxString result;
10096 void *argp1 = 0 ;
10097 int res1 = 0 ;
10098 PyObject *swig_obj[1] ;
10099
10100 if (!args) SWIG_fail;
10101 swig_obj[0] = args;
10102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10103 if (!SWIG_IsOK(res1)) {
10104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10105 }
10106 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10107 {
10108 PyThreadState* __tstate = wxPyBeginAllowThreads();
10109 result = (arg1)->GetTip();
10110 wxPyEndAllowThreads(__tstate);
10111 if (PyErr_Occurred()) SWIG_fail;
10112 }
10113 {
10114 #if wxUSE_UNICODE
10115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10116 #else
10117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10118 #endif
10119 }
10120 return resultobj;
10121 fail:
10122 return NULL;
10123 }
10124
10125
10126 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10127 PyObject *resultobj = 0;
10128 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10129 size_t result;
10130 void *argp1 = 0 ;
10131 int res1 = 0 ;
10132 PyObject *swig_obj[1] ;
10133
10134 if (!args) SWIG_fail;
10135 swig_obj[0] = args;
10136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10137 if (!SWIG_IsOK(res1)) {
10138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10139 }
10140 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10141 {
10142 PyThreadState* __tstate = wxPyBeginAllowThreads();
10143 result = (size_t)(arg1)->GetCurrentTip();
10144 wxPyEndAllowThreads(__tstate);
10145 if (PyErr_Occurred()) SWIG_fail;
10146 }
10147 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10148 return resultobj;
10149 fail:
10150 return NULL;
10151 }
10152
10153
10154 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10155 PyObject *resultobj = 0;
10156 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10157 wxString *arg2 = 0 ;
10158 wxString result;
10159 void *argp1 = 0 ;
10160 int res1 = 0 ;
10161 bool temp2 = false ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 char * kwnames[] = {
10165 (char *) "self",(char *) "tip", NULL
10166 };
10167
10168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10170 if (!SWIG_IsOK(res1)) {
10171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10172 }
10173 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10174 {
10175 arg2 = wxString_in_helper(obj1);
10176 if (arg2 == NULL) SWIG_fail;
10177 temp2 = true;
10178 }
10179 {
10180 PyThreadState* __tstate = wxPyBeginAllowThreads();
10181 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10182 wxPyEndAllowThreads(__tstate);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 {
10186 #if wxUSE_UNICODE
10187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10188 #else
10189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10190 #endif
10191 }
10192 {
10193 if (temp2)
10194 delete arg2;
10195 }
10196 return resultobj;
10197 fail:
10198 {
10199 if (temp2)
10200 delete arg2;
10201 }
10202 return NULL;
10203 }
10204
10205
10206 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10207 PyObject *obj;
10208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10209 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10210 return SWIG_Py_Void();
10211 }
10212
10213 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10214 PyObject *resultobj = 0;
10215 size_t arg1 ;
10216 wxPyTipProvider *result = 0 ;
10217 size_t val1 ;
10218 int ecode1 = 0 ;
10219 PyObject * obj0 = 0 ;
10220 char * kwnames[] = {
10221 (char *) "currentTip", NULL
10222 };
10223
10224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10225 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10226 if (!SWIG_IsOK(ecode1)) {
10227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10228 }
10229 arg1 = static_cast< size_t >(val1);
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10237 return resultobj;
10238 fail:
10239 return NULL;
10240 }
10241
10242
10243 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj = 0;
10245 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10246 PyObject *arg2 = (PyObject *) 0 ;
10247 PyObject *arg3 = (PyObject *) 0 ;
10248 void *argp1 = 0 ;
10249 int res1 = 0 ;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252 PyObject * obj2 = 0 ;
10253 char * kwnames[] = {
10254 (char *) "self",(char *) "self",(char *) "_class", NULL
10255 };
10256
10257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10259 if (!SWIG_IsOK(res1)) {
10260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10261 }
10262 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10263 arg2 = obj1;
10264 arg3 = obj2;
10265 {
10266 PyThreadState* __tstate = wxPyBeginAllowThreads();
10267 (arg1)->_setCallbackInfo(arg2,arg3);
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 resultobj = SWIG_Py_Void();
10272 return resultobj;
10273 fail:
10274 return NULL;
10275 }
10276
10277
10278 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10279 PyObject *obj;
10280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10281 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10282 return SWIG_Py_Void();
10283 }
10284
10285 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10286 return SWIG_Python_InitShadowInstance(args);
10287 }
10288
10289 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10290 PyObject *resultobj = 0;
10291 wxWindow *arg1 = (wxWindow *) 0 ;
10292 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10293 bool arg3 = (bool) true ;
10294 bool result;
10295 void *argp1 = 0 ;
10296 int res1 = 0 ;
10297 void *argp2 = 0 ;
10298 int res2 = 0 ;
10299 bool val3 ;
10300 int ecode3 = 0 ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 PyObject * obj2 = 0 ;
10304 char * kwnames[] = {
10305 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10306 };
10307
10308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10310 if (!SWIG_IsOK(res1)) {
10311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10312 }
10313 arg1 = reinterpret_cast< wxWindow * >(argp1);
10314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10315 if (!SWIG_IsOK(res2)) {
10316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10317 }
10318 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10319 if (obj2) {
10320 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10321 if (!SWIG_IsOK(ecode3)) {
10322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10323 }
10324 arg3 = static_cast< bool >(val3);
10325 }
10326 {
10327 if (!wxPyCheckForApp()) SWIG_fail;
10328 PyThreadState* __tstate = wxPyBeginAllowThreads();
10329 result = (bool)wxShowTip(arg1,arg2,arg3);
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 {
10334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10335 }
10336 return resultobj;
10337 fail:
10338 return NULL;
10339 }
10340
10341
10342 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10343 PyObject *resultobj = 0;
10344 wxString *arg1 = 0 ;
10345 size_t arg2 ;
10346 wxTipProvider *result = 0 ;
10347 bool temp1 = false ;
10348 size_t val2 ;
10349 int ecode2 = 0 ;
10350 PyObject * obj0 = 0 ;
10351 PyObject * obj1 = 0 ;
10352 char * kwnames[] = {
10353 (char *) "filename",(char *) "currentTip", NULL
10354 };
10355
10356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10357 {
10358 arg1 = wxString_in_helper(obj0);
10359 if (arg1 == NULL) SWIG_fail;
10360 temp1 = true;
10361 }
10362 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10363 if (!SWIG_IsOK(ecode2)) {
10364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10365 }
10366 arg2 = static_cast< size_t >(val2);
10367 {
10368 if (!wxPyCheckForApp()) SWIG_fail;
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10371 wxPyEndAllowThreads(__tstate);
10372 if (PyErr_Occurred()) SWIG_fail;
10373 }
10374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10375 {
10376 if (temp1)
10377 delete arg1;
10378 }
10379 return resultobj;
10380 fail:
10381 {
10382 if (temp1)
10383 delete arg1;
10384 }
10385 return NULL;
10386 }
10387
10388
10389 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10390 PyObject *resultobj = 0;
10391 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10392 int arg2 = (int) wxID_ANY ;
10393 wxPyTimer *result = 0 ;
10394 void *argp1 = 0 ;
10395 int res1 = 0 ;
10396 int val2 ;
10397 int ecode2 = 0 ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400 char * kwnames[] = {
10401 (char *) "owner",(char *) "id", NULL
10402 };
10403
10404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10405 if (obj0) {
10406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10407 if (!SWIG_IsOK(res1)) {
10408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10409 }
10410 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10411 }
10412 if (obj1) {
10413 ecode2 = SWIG_AsVal_int(obj1, &val2);
10414 if (!SWIG_IsOK(ecode2)) {
10415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10416 }
10417 arg2 = static_cast< int >(val2);
10418 }
10419 {
10420 if (!wxPyCheckForApp()) SWIG_fail;
10421 PyThreadState* __tstate = wxPyBeginAllowThreads();
10422 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10423 wxPyEndAllowThreads(__tstate);
10424 if (PyErr_Occurred()) SWIG_fail;
10425 }
10426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10427 return resultobj;
10428 fail:
10429 return NULL;
10430 }
10431
10432
10433 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10434 PyObject *resultobj = 0;
10435 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10436 void *argp1 = 0 ;
10437 int res1 = 0 ;
10438 PyObject *swig_obj[1] ;
10439
10440 if (!args) SWIG_fail;
10441 swig_obj[0] = args;
10442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10443 if (!SWIG_IsOK(res1)) {
10444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10445 }
10446 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10447 {
10448 PyThreadState* __tstate = wxPyBeginAllowThreads();
10449 delete arg1;
10450
10451 wxPyEndAllowThreads(__tstate);
10452 if (PyErr_Occurred()) SWIG_fail;
10453 }
10454 resultobj = SWIG_Py_Void();
10455 return resultobj;
10456 fail:
10457 return NULL;
10458 }
10459
10460
10461 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10462 PyObject *resultobj = 0;
10463 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10464 PyObject *arg2 = (PyObject *) 0 ;
10465 PyObject *arg3 = (PyObject *) 0 ;
10466 int arg4 = (int) 1 ;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 int val4 ;
10470 int ecode4 = 0 ;
10471 PyObject * obj0 = 0 ;
10472 PyObject * obj1 = 0 ;
10473 PyObject * obj2 = 0 ;
10474 PyObject * obj3 = 0 ;
10475 char * kwnames[] = {
10476 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10477 };
10478
10479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10481 if (!SWIG_IsOK(res1)) {
10482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10483 }
10484 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10485 arg2 = obj1;
10486 arg3 = obj2;
10487 if (obj3) {
10488 ecode4 = SWIG_AsVal_int(obj3, &val4);
10489 if (!SWIG_IsOK(ecode4)) {
10490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10491 }
10492 arg4 = static_cast< int >(val4);
10493 }
10494 {
10495 PyThreadState* __tstate = wxPyBeginAllowThreads();
10496 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10497 wxPyEndAllowThreads(__tstate);
10498 if (PyErr_Occurred()) SWIG_fail;
10499 }
10500 resultobj = SWIG_Py_Void();
10501 return resultobj;
10502 fail:
10503 return NULL;
10504 }
10505
10506
10507 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10508 PyObject *resultobj = 0;
10509 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10510 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10511 int arg3 = (int) wxID_ANY ;
10512 void *argp1 = 0 ;
10513 int res1 = 0 ;
10514 void *argp2 = 0 ;
10515 int res2 = 0 ;
10516 int val3 ;
10517 int ecode3 = 0 ;
10518 PyObject * obj0 = 0 ;
10519 PyObject * obj1 = 0 ;
10520 PyObject * obj2 = 0 ;
10521 char * kwnames[] = {
10522 (char *) "self",(char *) "owner",(char *) "id", NULL
10523 };
10524
10525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10527 if (!SWIG_IsOK(res1)) {
10528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10529 }
10530 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10531 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10532 if (!SWIG_IsOK(res2)) {
10533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10534 }
10535 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10536 if (obj2) {
10537 ecode3 = SWIG_AsVal_int(obj2, &val3);
10538 if (!SWIG_IsOK(ecode3)) {
10539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10540 }
10541 arg3 = static_cast< int >(val3);
10542 }
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 (arg1)->SetOwner(arg2,arg3);
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 resultobj = SWIG_Py_Void();
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10557 PyObject *resultobj = 0;
10558 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10559 wxEvtHandler *result = 0 ;
10560 void *argp1 = 0 ;
10561 int res1 = 0 ;
10562 PyObject *swig_obj[1] ;
10563
10564 if (!args) SWIG_fail;
10565 swig_obj[0] = args;
10566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10567 if (!SWIG_IsOK(res1)) {
10568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10569 }
10570 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10571 {
10572 PyThreadState* __tstate = wxPyBeginAllowThreads();
10573 result = (wxEvtHandler *)(arg1)->GetOwner();
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 {
10578 resultobj = wxPyMake_wxObject(result, 0);
10579 }
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj = 0;
10588 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10589 int arg2 = (int) -1 ;
10590 bool arg3 = (bool) false ;
10591 bool result;
10592 void *argp1 = 0 ;
10593 int res1 = 0 ;
10594 int val2 ;
10595 int ecode2 = 0 ;
10596 bool val3 ;
10597 int ecode3 = 0 ;
10598 PyObject * obj0 = 0 ;
10599 PyObject * obj1 = 0 ;
10600 PyObject * obj2 = 0 ;
10601 char * kwnames[] = {
10602 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10603 };
10604
10605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10607 if (!SWIG_IsOK(res1)) {
10608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10609 }
10610 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10611 if (obj1) {
10612 ecode2 = SWIG_AsVal_int(obj1, &val2);
10613 if (!SWIG_IsOK(ecode2)) {
10614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10615 }
10616 arg2 = static_cast< int >(val2);
10617 }
10618 if (obj2) {
10619 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10620 if (!SWIG_IsOK(ecode3)) {
10621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10622 }
10623 arg3 = static_cast< bool >(val3);
10624 }
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 result = (bool)(arg1)->Start(arg2,arg3);
10628 wxPyEndAllowThreads(__tstate);
10629 if (PyErr_Occurred()) SWIG_fail;
10630 }
10631 {
10632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10633 }
10634 return resultobj;
10635 fail:
10636 return NULL;
10637 }
10638
10639
10640 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10641 PyObject *resultobj = 0;
10642 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10643 void *argp1 = 0 ;
10644 int res1 = 0 ;
10645 PyObject *swig_obj[1] ;
10646
10647 if (!args) SWIG_fail;
10648 swig_obj[0] = args;
10649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10650 if (!SWIG_IsOK(res1)) {
10651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10652 }
10653 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10654 {
10655 PyThreadState* __tstate = wxPyBeginAllowThreads();
10656 (arg1)->Stop();
10657 wxPyEndAllowThreads(__tstate);
10658 if (PyErr_Occurred()) SWIG_fail;
10659 }
10660 resultobj = SWIG_Py_Void();
10661 return resultobj;
10662 fail:
10663 return NULL;
10664 }
10665
10666
10667 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10668 PyObject *resultobj = 0;
10669 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10670 void *argp1 = 0 ;
10671 int res1 = 0 ;
10672 PyObject *swig_obj[1] ;
10673
10674 if (!args) SWIG_fail;
10675 swig_obj[0] = args;
10676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10677 if (!SWIG_IsOK(res1)) {
10678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10679 }
10680 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10681 {
10682 PyThreadState* __tstate = wxPyBeginAllowThreads();
10683 (arg1)->Notify();
10684 wxPyEndAllowThreads(__tstate);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 resultobj = SWIG_Py_Void();
10688 return resultobj;
10689 fail:
10690 return NULL;
10691 }
10692
10693
10694 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10695 PyObject *resultobj = 0;
10696 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10697 bool result;
10698 void *argp1 = 0 ;
10699 int res1 = 0 ;
10700 PyObject *swig_obj[1] ;
10701
10702 if (!args) SWIG_fail;
10703 swig_obj[0] = args;
10704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10705 if (!SWIG_IsOK(res1)) {
10706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10707 }
10708 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10709 {
10710 PyThreadState* __tstate = wxPyBeginAllowThreads();
10711 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10712 wxPyEndAllowThreads(__tstate);
10713 if (PyErr_Occurred()) SWIG_fail;
10714 }
10715 {
10716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10717 }
10718 return resultobj;
10719 fail:
10720 return NULL;
10721 }
10722
10723
10724 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10725 PyObject *resultobj = 0;
10726 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10727 int result;
10728 void *argp1 = 0 ;
10729 int res1 = 0 ;
10730 PyObject *swig_obj[1] ;
10731
10732 if (!args) SWIG_fail;
10733 swig_obj[0] = args;
10734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10735 if (!SWIG_IsOK(res1)) {
10736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10737 }
10738 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10739 {
10740 PyThreadState* __tstate = wxPyBeginAllowThreads();
10741 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10742 wxPyEndAllowThreads(__tstate);
10743 if (PyErr_Occurred()) SWIG_fail;
10744 }
10745 resultobj = SWIG_From_int(static_cast< int >(result));
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10753 PyObject *resultobj = 0;
10754 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10755 int result;
10756 void *argp1 = 0 ;
10757 int res1 = 0 ;
10758 PyObject *swig_obj[1] ;
10759
10760 if (!args) SWIG_fail;
10761 swig_obj[0] = args;
10762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10763 if (!SWIG_IsOK(res1)) {
10764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10765 }
10766 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 result = (int)((wxPyTimer const *)arg1)->GetId();
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 resultobj = SWIG_From_int(static_cast< int >(result));
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10781 PyObject *resultobj = 0;
10782 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10783 bool result;
10784 void *argp1 = 0 ;
10785 int res1 = 0 ;
10786 PyObject *swig_obj[1] ;
10787
10788 if (!args) SWIG_fail;
10789 swig_obj[0] = args;
10790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10791 if (!SWIG_IsOK(res1)) {
10792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10793 }
10794 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10795 {
10796 PyThreadState* __tstate = wxPyBeginAllowThreads();
10797 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10798 wxPyEndAllowThreads(__tstate);
10799 if (PyErr_Occurred()) SWIG_fail;
10800 }
10801 {
10802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10803 }
10804 return resultobj;
10805 fail:
10806 return NULL;
10807 }
10808
10809
10810 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10811 PyObject *obj;
10812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10813 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10814 return SWIG_Py_Void();
10815 }
10816
10817 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10818 return SWIG_Python_InitShadowInstance(args);
10819 }
10820
10821 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj = 0;
10823 int arg1 = (int) 0 ;
10824 int arg2 = (int) 0 ;
10825 wxTimerEvent *result = 0 ;
10826 int val1 ;
10827 int ecode1 = 0 ;
10828 int val2 ;
10829 int ecode2 = 0 ;
10830 PyObject * obj0 = 0 ;
10831 PyObject * obj1 = 0 ;
10832 char * kwnames[] = {
10833 (char *) "timerid",(char *) "interval", NULL
10834 };
10835
10836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10837 if (obj0) {
10838 ecode1 = SWIG_AsVal_int(obj0, &val1);
10839 if (!SWIG_IsOK(ecode1)) {
10840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10841 }
10842 arg1 = static_cast< int >(val1);
10843 }
10844 if (obj1) {
10845 ecode2 = SWIG_AsVal_int(obj1, &val2);
10846 if (!SWIG_IsOK(ecode2)) {
10847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10848 }
10849 arg2 = static_cast< int >(val2);
10850 }
10851 {
10852 PyThreadState* __tstate = wxPyBeginAllowThreads();
10853 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10865 PyObject *resultobj = 0;
10866 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10867 int result;
10868 void *argp1 = 0 ;
10869 int res1 = 0 ;
10870 PyObject *swig_obj[1] ;
10871
10872 if (!args) SWIG_fail;
10873 swig_obj[0] = args;
10874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10875 if (!SWIG_IsOK(res1)) {
10876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10877 }
10878 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10879 {
10880 PyThreadState* __tstate = wxPyBeginAllowThreads();
10881 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10882 wxPyEndAllowThreads(__tstate);
10883 if (PyErr_Occurred()) SWIG_fail;
10884 }
10885 resultobj = SWIG_From_int(static_cast< int >(result));
10886 return resultobj;
10887 fail:
10888 return NULL;
10889 }
10890
10891
10892 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10893 PyObject *obj;
10894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10895 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10896 return SWIG_Py_Void();
10897 }
10898
10899 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10900 return SWIG_Python_InitShadowInstance(args);
10901 }
10902
10903 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10904 PyObject *resultobj = 0;
10905 wxTimer *arg1 = 0 ;
10906 wxTimerRunner *result = 0 ;
10907 void *argp1 = 0 ;
10908 int res1 = 0 ;
10909
10910 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10912 if (!SWIG_IsOK(res1)) {
10913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10914 }
10915 if (!argp1) {
10916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10917 }
10918 arg1 = reinterpret_cast< wxTimer * >(argp1);
10919 {
10920 if (!wxPyCheckForApp()) SWIG_fail;
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10934 PyObject *resultobj = 0;
10935 wxTimer *arg1 = 0 ;
10936 int arg2 ;
10937 bool arg3 = (bool) false ;
10938 wxTimerRunner *result = 0 ;
10939 void *argp1 = 0 ;
10940 int res1 = 0 ;
10941 int val2 ;
10942 int ecode2 = 0 ;
10943 bool val3 ;
10944 int ecode3 = 0 ;
10945
10946 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10948 if (!SWIG_IsOK(res1)) {
10949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10950 }
10951 if (!argp1) {
10952 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10953 }
10954 arg1 = reinterpret_cast< wxTimer * >(argp1);
10955 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10956 if (!SWIG_IsOK(ecode2)) {
10957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10958 }
10959 arg2 = static_cast< int >(val2);
10960 if (swig_obj[2]) {
10961 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10962 if (!SWIG_IsOK(ecode3)) {
10963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10964 }
10965 arg3 = static_cast< bool >(val3);
10966 }
10967 {
10968 if (!wxPyCheckForApp()) SWIG_fail;
10969 PyThreadState* __tstate = wxPyBeginAllowThreads();
10970 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10971 wxPyEndAllowThreads(__tstate);
10972 if (PyErr_Occurred()) SWIG_fail;
10973 }
10974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10982 int argc;
10983 PyObject *argv[4];
10984
10985 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10986 --argc;
10987 if (argc == 1) {
10988 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10989 }
10990 if ((argc >= 2) && (argc <= 3)) {
10991 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10992 }
10993
10994 fail:
10995 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10996 return NULL;
10997 }
10998
10999
11000 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11001 PyObject *resultobj = 0;
11002 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11003 void *argp1 = 0 ;
11004 int res1 = 0 ;
11005 PyObject *swig_obj[1] ;
11006
11007 if (!args) SWIG_fail;
11008 swig_obj[0] = args;
11009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11010 if (!SWIG_IsOK(res1)) {
11011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11012 }
11013 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11014 {
11015 PyThreadState* __tstate = wxPyBeginAllowThreads();
11016 delete arg1;
11017
11018 wxPyEndAllowThreads(__tstate);
11019 if (PyErr_Occurred()) SWIG_fail;
11020 }
11021 resultobj = SWIG_Py_Void();
11022 return resultobj;
11023 fail:
11024 return NULL;
11025 }
11026
11027
11028 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj = 0;
11030 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11031 int arg2 ;
11032 bool arg3 = (bool) false ;
11033 void *argp1 = 0 ;
11034 int res1 = 0 ;
11035 int val2 ;
11036 int ecode2 = 0 ;
11037 bool val3 ;
11038 int ecode3 = 0 ;
11039 PyObject * obj0 = 0 ;
11040 PyObject * obj1 = 0 ;
11041 PyObject * obj2 = 0 ;
11042 char * kwnames[] = {
11043 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11044 };
11045
11046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11048 if (!SWIG_IsOK(res1)) {
11049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11050 }
11051 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11052 ecode2 = SWIG_AsVal_int(obj1, &val2);
11053 if (!SWIG_IsOK(ecode2)) {
11054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11055 }
11056 arg2 = static_cast< int >(val2);
11057 if (obj2) {
11058 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11059 if (!SWIG_IsOK(ecode3)) {
11060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11061 }
11062 arg3 = static_cast< bool >(val3);
11063 }
11064 {
11065 PyThreadState* __tstate = wxPyBeginAllowThreads();
11066 (arg1)->Start(arg2,arg3);
11067 wxPyEndAllowThreads(__tstate);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 resultobj = SWIG_Py_Void();
11071 return resultobj;
11072 fail:
11073 return NULL;
11074 }
11075
11076
11077 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11078 PyObject *obj;
11079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11080 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11081 return SWIG_Py_Void();
11082 }
11083
11084 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11085 return SWIG_Python_InitShadowInstance(args);
11086 }
11087
11088 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11089 PyObject *resultobj = 0;
11090 wxLog *result = 0 ;
11091
11092 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11093 {
11094 PyThreadState* __tstate = wxPyBeginAllowThreads();
11095 result = (wxLog *)new wxLog();
11096 wxPyEndAllowThreads(__tstate);
11097 if (PyErr_Occurred()) SWIG_fail;
11098 }
11099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11100 return resultobj;
11101 fail:
11102 return NULL;
11103 }
11104
11105
11106 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11107 PyObject *resultobj = 0;
11108 wxLog *arg1 = (wxLog *) 0 ;
11109 void *argp1 = 0 ;
11110 int res1 = 0 ;
11111 PyObject *swig_obj[1] ;
11112
11113 if (!args) SWIG_fail;
11114 swig_obj[0] = args;
11115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11116 if (!SWIG_IsOK(res1)) {
11117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11118 }
11119 arg1 = reinterpret_cast< wxLog * >(argp1);
11120 {
11121 PyThreadState* __tstate = wxPyBeginAllowThreads();
11122 delete arg1;
11123
11124 wxPyEndAllowThreads(__tstate);
11125 if (PyErr_Occurred()) SWIG_fail;
11126 }
11127 resultobj = SWIG_Py_Void();
11128 return resultobj;
11129 fail:
11130 return NULL;
11131 }
11132
11133
11134 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11135 PyObject *resultobj = 0;
11136 bool result;
11137
11138 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 result = (bool)wxLog::IsEnabled();
11142 wxPyEndAllowThreads(__tstate);
11143 if (PyErr_Occurred()) SWIG_fail;
11144 }
11145 {
11146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11147 }
11148 return resultobj;
11149 fail:
11150 return NULL;
11151 }
11152
11153
11154 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11155 PyObject *resultobj = 0;
11156 bool arg1 = (bool) true ;
11157 bool result;
11158 bool val1 ;
11159 int ecode1 = 0 ;
11160 PyObject * obj0 = 0 ;
11161 char * kwnames[] = {
11162 (char *) "doIt", NULL
11163 };
11164
11165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11166 if (obj0) {
11167 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11168 if (!SWIG_IsOK(ecode1)) {
11169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11170 }
11171 arg1 = static_cast< bool >(val1);
11172 }
11173 {
11174 PyThreadState* __tstate = wxPyBeginAllowThreads();
11175 result = (bool)wxLog::EnableLogging(arg1);
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 {
11180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11181 }
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11189 PyObject *resultobj = 0;
11190 wxLogLevel arg1 ;
11191 wxChar *arg2 = (wxChar *) 0 ;
11192 time_t arg3 ;
11193 unsigned long val1 ;
11194 int ecode1 = 0 ;
11195 void *argp2 = 0 ;
11196 int res2 = 0 ;
11197 unsigned int val3 ;
11198 int ecode3 = 0 ;
11199 PyObject * obj0 = 0 ;
11200 PyObject * obj1 = 0 ;
11201 PyObject * obj2 = 0 ;
11202 char * kwnames[] = {
11203 (char *) "level",(char *) "szString",(char *) "t", NULL
11204 };
11205
11206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11207 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11208 if (!SWIG_IsOK(ecode1)) {
11209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11210 }
11211 arg1 = static_cast< wxLogLevel >(val1);
11212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11213 if (!SWIG_IsOK(res2)) {
11214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11215 }
11216 arg2 = reinterpret_cast< wxChar * >(argp2);
11217 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11218 if (!SWIG_IsOK(ecode3)) {
11219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11220 }
11221 arg3 = static_cast< time_t >(val3);
11222 {
11223 PyThreadState* __tstate = wxPyBeginAllowThreads();
11224 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11225 wxPyEndAllowThreads(__tstate);
11226 if (PyErr_Occurred()) SWIG_fail;
11227 }
11228 resultobj = SWIG_Py_Void();
11229 return resultobj;
11230 fail:
11231 return NULL;
11232 }
11233
11234
11235 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11236 PyObject *resultobj = 0;
11237 wxLog *arg1 = (wxLog *) 0 ;
11238 void *argp1 = 0 ;
11239 int res1 = 0 ;
11240 PyObject *swig_obj[1] ;
11241
11242 if (!args) SWIG_fail;
11243 swig_obj[0] = args;
11244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11245 if (!SWIG_IsOK(res1)) {
11246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11247 }
11248 arg1 = reinterpret_cast< wxLog * >(argp1);
11249 {
11250 PyThreadState* __tstate = wxPyBeginAllowThreads();
11251 (arg1)->Flush();
11252 wxPyEndAllowThreads(__tstate);
11253 if (PyErr_Occurred()) SWIG_fail;
11254 }
11255 resultobj = SWIG_Py_Void();
11256 return resultobj;
11257 fail:
11258 return NULL;
11259 }
11260
11261
11262 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11263 PyObject *resultobj = 0;
11264
11265 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11266 {
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 wxLog::FlushActive();
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 resultobj = SWIG_Py_Void();
11273 return resultobj;
11274 fail:
11275 return NULL;
11276 }
11277
11278
11279 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11280 PyObject *resultobj = 0;
11281 wxLog *result = 0 ;
11282
11283 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11284 {
11285 PyThreadState* __tstate = wxPyBeginAllowThreads();
11286 result = (wxLog *)wxLog::GetActiveTarget();
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11291 return resultobj;
11292 fail:
11293 return NULL;
11294 }
11295
11296
11297 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11298 PyObject *resultobj = 0;
11299 wxLog *arg1 = (wxLog *) 0 ;
11300 wxLog *result = 0 ;
11301 int res1 = 0 ;
11302 PyObject * obj0 = 0 ;
11303 char * kwnames[] = {
11304 (char *) "pLogger", NULL
11305 };
11306
11307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11308 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11309 if (!SWIG_IsOK(res1)) {
11310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11311 }
11312 {
11313 PyThreadState* __tstate = wxPyBeginAllowThreads();
11314 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11315 wxPyEndAllowThreads(__tstate);
11316 if (PyErr_Occurred()) SWIG_fail;
11317 }
11318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11319 return resultobj;
11320 fail:
11321 return NULL;
11322 }
11323
11324
11325 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11326 PyObject *resultobj = 0;
11327
11328 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11329 {
11330 PyThreadState* __tstate = wxPyBeginAllowThreads();
11331 wxLog::Suspend();
11332 wxPyEndAllowThreads(__tstate);
11333 if (PyErr_Occurred()) SWIG_fail;
11334 }
11335 resultobj = SWIG_Py_Void();
11336 return resultobj;
11337 fail:
11338 return NULL;
11339 }
11340
11341
11342 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11343 PyObject *resultobj = 0;
11344
11345 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11346 {
11347 PyThreadState* __tstate = wxPyBeginAllowThreads();
11348 wxLog::Resume();
11349 wxPyEndAllowThreads(__tstate);
11350 if (PyErr_Occurred()) SWIG_fail;
11351 }
11352 resultobj = SWIG_Py_Void();
11353 return resultobj;
11354 fail:
11355 return NULL;
11356 }
11357
11358
11359 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11360 PyObject *resultobj = 0;
11361 bool arg1 = (bool) true ;
11362 bool val1 ;
11363 int ecode1 = 0 ;
11364 PyObject * obj0 = 0 ;
11365 char * kwnames[] = {
11366 (char *) "bVerbose", NULL
11367 };
11368
11369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11370 if (obj0) {
11371 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11372 if (!SWIG_IsOK(ecode1)) {
11373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11374 }
11375 arg1 = static_cast< bool >(val1);
11376 }
11377 {
11378 PyThreadState* __tstate = wxPyBeginAllowThreads();
11379 wxLog::SetVerbose(arg1);
11380 wxPyEndAllowThreads(__tstate);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 resultobj = SWIG_Py_Void();
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj = 0;
11392 wxLogLevel arg1 ;
11393 unsigned long val1 ;
11394 int ecode1 = 0 ;
11395 PyObject * obj0 = 0 ;
11396 char * kwnames[] = {
11397 (char *) "logLevel", NULL
11398 };
11399
11400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11401 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11402 if (!SWIG_IsOK(ecode1)) {
11403 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11404 }
11405 arg1 = static_cast< wxLogLevel >(val1);
11406 {
11407 PyThreadState* __tstate = wxPyBeginAllowThreads();
11408 wxLog::SetLogLevel(arg1);
11409 wxPyEndAllowThreads(__tstate);
11410 if (PyErr_Occurred()) SWIG_fail;
11411 }
11412 resultobj = SWIG_Py_Void();
11413 return resultobj;
11414 fail:
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11420 PyObject *resultobj = 0;
11421
11422 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 wxLog::DontCreateOnDemand();
11426 wxPyEndAllowThreads(__tstate);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 resultobj = SWIG_Py_Void();
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11437 PyObject *resultobj = 0;
11438 wxTraceMask arg1 ;
11439 unsigned long val1 ;
11440 int ecode1 = 0 ;
11441 PyObject * obj0 = 0 ;
11442 char * kwnames[] = {
11443 (char *) "ulMask", NULL
11444 };
11445
11446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11447 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11448 if (!SWIG_IsOK(ecode1)) {
11449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11450 }
11451 arg1 = static_cast< wxTraceMask >(val1);
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 wxLog::SetTraceMask(arg1);
11455 wxPyEndAllowThreads(__tstate);
11456 if (PyErr_Occurred()) SWIG_fail;
11457 }
11458 resultobj = SWIG_Py_Void();
11459 return resultobj;
11460 fail:
11461 return NULL;
11462 }
11463
11464
11465 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj = 0;
11467 wxString *arg1 = 0 ;
11468 bool temp1 = false ;
11469 PyObject * obj0 = 0 ;
11470 char * kwnames[] = {
11471 (char *) "str", NULL
11472 };
11473
11474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11475 {
11476 arg1 = wxString_in_helper(obj0);
11477 if (arg1 == NULL) SWIG_fail;
11478 temp1 = true;
11479 }
11480 {
11481 PyThreadState* __tstate = wxPyBeginAllowThreads();
11482 wxLog::AddTraceMask((wxString const &)*arg1);
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 resultobj = SWIG_Py_Void();
11487 {
11488 if (temp1)
11489 delete arg1;
11490 }
11491 return resultobj;
11492 fail:
11493 {
11494 if (temp1)
11495 delete arg1;
11496 }
11497 return NULL;
11498 }
11499
11500
11501 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj = 0;
11503 wxString *arg1 = 0 ;
11504 bool temp1 = false ;
11505 PyObject * obj0 = 0 ;
11506 char * kwnames[] = {
11507 (char *) "str", NULL
11508 };
11509
11510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11511 {
11512 arg1 = wxString_in_helper(obj0);
11513 if (arg1 == NULL) SWIG_fail;
11514 temp1 = true;
11515 }
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 wxLog::RemoveTraceMask((wxString const &)*arg1);
11519 wxPyEndAllowThreads(__tstate);
11520 if (PyErr_Occurred()) SWIG_fail;
11521 }
11522 resultobj = SWIG_Py_Void();
11523 {
11524 if (temp1)
11525 delete arg1;
11526 }
11527 return resultobj;
11528 fail:
11529 {
11530 if (temp1)
11531 delete arg1;
11532 }
11533 return NULL;
11534 }
11535
11536
11537 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11538 PyObject *resultobj = 0;
11539
11540 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 wxLog::ClearTraceMasks();
11544 wxPyEndAllowThreads(__tstate);
11545 if (PyErr_Occurred()) SWIG_fail;
11546 }
11547 resultobj = SWIG_Py_Void();
11548 return resultobj;
11549 fail:
11550 return NULL;
11551 }
11552
11553
11554 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11555 PyObject *resultobj = 0;
11556 wxArrayString *result = 0 ;
11557
11558 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 {
11562 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11563 result = (wxArrayString *) &_result_ref;
11564 }
11565 wxPyEndAllowThreads(__tstate);
11566 if (PyErr_Occurred()) SWIG_fail;
11567 }
11568 {
11569 resultobj = wxArrayString2PyList_helper(*result);
11570 }
11571 return resultobj;
11572 fail:
11573 return NULL;
11574 }
11575
11576
11577 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11578 PyObject *resultobj = 0;
11579 wxChar *arg1 = (wxChar *) 0 ;
11580 void *argp1 = 0 ;
11581 int res1 = 0 ;
11582 PyObject * obj0 = 0 ;
11583 char * kwnames[] = {
11584 (char *) "ts", NULL
11585 };
11586
11587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11589 if (!SWIG_IsOK(res1)) {
11590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11591 }
11592 arg1 = reinterpret_cast< wxChar * >(argp1);
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 wxLog::SetTimestamp((wxChar const *)arg1);
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 resultobj = SWIG_Py_Void();
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11607 PyObject *resultobj = 0;
11608 bool result;
11609
11610 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (bool)wxLog::GetVerbose();
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 {
11618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11619 }
11620 return resultobj;
11621 fail:
11622 return NULL;
11623 }
11624
11625
11626 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11627 PyObject *resultobj = 0;
11628 wxTraceMask result;
11629
11630 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11631 {
11632 PyThreadState* __tstate = wxPyBeginAllowThreads();
11633 result = (wxTraceMask)wxLog::GetTraceMask();
11634 wxPyEndAllowThreads(__tstate);
11635 if (PyErr_Occurred()) SWIG_fail;
11636 }
11637 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11645 PyObject *resultobj = 0;
11646 wxChar *arg1 = (wxChar *) 0 ;
11647 bool result;
11648 void *argp1 = 0 ;
11649 int res1 = 0 ;
11650 PyObject * obj0 = 0 ;
11651 char * kwnames[] = {
11652 (char *) "mask", NULL
11653 };
11654
11655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11657 if (!SWIG_IsOK(res1)) {
11658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11659 }
11660 arg1 = reinterpret_cast< wxChar * >(argp1);
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11664 wxPyEndAllowThreads(__tstate);
11665 if (PyErr_Occurred()) SWIG_fail;
11666 }
11667 {
11668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11669 }
11670 return resultobj;
11671 fail:
11672 return NULL;
11673 }
11674
11675
11676 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11677 PyObject *resultobj = 0;
11678 wxLogLevel result;
11679
11680 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (wxLogLevel)wxLog::GetLogLevel();
11684 wxPyEndAllowThreads(__tstate);
11685 if (PyErr_Occurred()) SWIG_fail;
11686 }
11687 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11688 return resultobj;
11689 fail:
11690 return NULL;
11691 }
11692
11693
11694 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11695 PyObject *resultobj = 0;
11696 wxChar *result = 0 ;
11697
11698 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11699 {
11700 PyThreadState* __tstate = wxPyBeginAllowThreads();
11701 result = (wxChar *)wxLog::GetTimestamp();
11702 wxPyEndAllowThreads(__tstate);
11703 if (PyErr_Occurred()) SWIG_fail;
11704 }
11705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11706 return resultobj;
11707 fail:
11708 return NULL;
11709 }
11710
11711
11712 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11713 PyObject *resultobj = 0;
11714 wxString result;
11715
11716 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = wxLog_TimeStamp();
11720 wxPyEndAllowThreads(__tstate);
11721 if (PyErr_Occurred()) SWIG_fail;
11722 }
11723 {
11724 #if wxUSE_UNICODE
11725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11726 #else
11727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11728 #endif
11729 }
11730 return resultobj;
11731 fail:
11732 return NULL;
11733 }
11734
11735
11736 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737 PyObject *resultobj = 0;
11738 wxLog *arg1 = (wxLog *) 0 ;
11739 void *argp1 = 0 ;
11740 int res1 = 0 ;
11741 PyObject *swig_obj[1] ;
11742
11743 if (!args) SWIG_fail;
11744 swig_obj[0] = args;
11745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11746 if (!SWIG_IsOK(res1)) {
11747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11748 }
11749 arg1 = reinterpret_cast< wxLog * >(argp1);
11750 {
11751 PyThreadState* __tstate = wxPyBeginAllowThreads();
11752 wxLog_Destroy(arg1);
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 resultobj = SWIG_Py_Void();
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11764 PyObject *obj;
11765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11766 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11767 return SWIG_Py_Void();
11768 }
11769
11770 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11771 return SWIG_Python_InitShadowInstance(args);
11772 }
11773
11774 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11775 PyObject *resultobj = 0;
11776 wxLogStderr *result = 0 ;
11777
11778 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11779 {
11780 PyThreadState* __tstate = wxPyBeginAllowThreads();
11781 result = (wxLogStderr *)new wxLogStderr();
11782 wxPyEndAllowThreads(__tstate);
11783 if (PyErr_Occurred()) SWIG_fail;
11784 }
11785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11786 return resultobj;
11787 fail:
11788 return NULL;
11789 }
11790
11791
11792 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11793 PyObject *obj;
11794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11795 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11796 return SWIG_Py_Void();
11797 }
11798
11799 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11800 return SWIG_Python_InitShadowInstance(args);
11801 }
11802
11803 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11804 PyObject *resultobj = 0;
11805 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11806 wxLogTextCtrl *result = 0 ;
11807 void *argp1 = 0 ;
11808 int res1 = 0 ;
11809 PyObject * obj0 = 0 ;
11810 char * kwnames[] = {
11811 (char *) "pTextCtrl", NULL
11812 };
11813
11814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11816 if (!SWIG_IsOK(res1)) {
11817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11818 }
11819 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11820 {
11821 PyThreadState* __tstate = wxPyBeginAllowThreads();
11822 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11823 wxPyEndAllowThreads(__tstate);
11824 if (PyErr_Occurred()) SWIG_fail;
11825 }
11826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11827 return resultobj;
11828 fail:
11829 return NULL;
11830 }
11831
11832
11833 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11834 PyObject *obj;
11835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11836 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11837 return SWIG_Py_Void();
11838 }
11839
11840 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11841 return SWIG_Python_InitShadowInstance(args);
11842 }
11843
11844 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11845 PyObject *resultobj = 0;
11846 wxLogGui *result = 0 ;
11847
11848 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (wxLogGui *)new wxLogGui();
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11856 return resultobj;
11857 fail:
11858 return NULL;
11859 }
11860
11861
11862 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11863 PyObject *obj;
11864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11865 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11866 return SWIG_Py_Void();
11867 }
11868
11869 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11870 return SWIG_Python_InitShadowInstance(args);
11871 }
11872
11873 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11874 PyObject *resultobj = 0;
11875 wxFrame *arg1 = (wxFrame *) 0 ;
11876 wxString *arg2 = 0 ;
11877 bool arg3 = (bool) true ;
11878 bool arg4 = (bool) true ;
11879 wxLogWindow *result = 0 ;
11880 void *argp1 = 0 ;
11881 int res1 = 0 ;
11882 bool temp2 = false ;
11883 bool val3 ;
11884 int ecode3 = 0 ;
11885 bool val4 ;
11886 int ecode4 = 0 ;
11887 PyObject * obj0 = 0 ;
11888 PyObject * obj1 = 0 ;
11889 PyObject * obj2 = 0 ;
11890 PyObject * obj3 = 0 ;
11891 char * kwnames[] = {
11892 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11893 };
11894
11895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11897 if (!SWIG_IsOK(res1)) {
11898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11899 }
11900 arg1 = reinterpret_cast< wxFrame * >(argp1);
11901 {
11902 arg2 = wxString_in_helper(obj1);
11903 if (arg2 == NULL) SWIG_fail;
11904 temp2 = true;
11905 }
11906 if (obj2) {
11907 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11908 if (!SWIG_IsOK(ecode3)) {
11909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11910 }
11911 arg3 = static_cast< bool >(val3);
11912 }
11913 if (obj3) {
11914 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11915 if (!SWIG_IsOK(ecode4)) {
11916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11917 }
11918 arg4 = static_cast< bool >(val4);
11919 }
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11927 {
11928 if (temp2)
11929 delete arg2;
11930 }
11931 return resultobj;
11932 fail:
11933 {
11934 if (temp2)
11935 delete arg2;
11936 }
11937 return NULL;
11938 }
11939
11940
11941 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11942 PyObject *resultobj = 0;
11943 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11944 bool arg2 = (bool) true ;
11945 void *argp1 = 0 ;
11946 int res1 = 0 ;
11947 bool val2 ;
11948 int ecode2 = 0 ;
11949 PyObject * obj0 = 0 ;
11950 PyObject * obj1 = 0 ;
11951 char * kwnames[] = {
11952 (char *) "self",(char *) "bShow", NULL
11953 };
11954
11955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11957 if (!SWIG_IsOK(res1)) {
11958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11959 }
11960 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11961 if (obj1) {
11962 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11963 if (!SWIG_IsOK(ecode2)) {
11964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11965 }
11966 arg2 = static_cast< bool >(val2);
11967 }
11968 {
11969 PyThreadState* __tstate = wxPyBeginAllowThreads();
11970 (arg1)->Show(arg2);
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 resultobj = SWIG_Py_Void();
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11982 PyObject *resultobj = 0;
11983 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11984 wxFrame *result = 0 ;
11985 void *argp1 = 0 ;
11986 int res1 = 0 ;
11987 PyObject *swig_obj[1] ;
11988
11989 if (!args) SWIG_fail;
11990 swig_obj[0] = args;
11991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11992 if (!SWIG_IsOK(res1)) {
11993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11994 }
11995 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 {
12003 resultobj = wxPyMake_wxObject(result, (bool)0);
12004 }
12005 return resultobj;
12006 fail:
12007 return NULL;
12008 }
12009
12010
12011 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12012 PyObject *resultobj = 0;
12013 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12014 wxLog *result = 0 ;
12015 void *argp1 = 0 ;
12016 int res1 = 0 ;
12017 PyObject *swig_obj[1] ;
12018
12019 if (!args) SWIG_fail;
12020 swig_obj[0] = args;
12021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12022 if (!SWIG_IsOK(res1)) {
12023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12024 }
12025 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12026 {
12027 PyThreadState* __tstate = wxPyBeginAllowThreads();
12028 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12029 wxPyEndAllowThreads(__tstate);
12030 if (PyErr_Occurred()) SWIG_fail;
12031 }
12032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12033 return resultobj;
12034 fail:
12035 return NULL;
12036 }
12037
12038
12039 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12040 PyObject *resultobj = 0;
12041 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12042 bool result;
12043 void *argp1 = 0 ;
12044 int res1 = 0 ;
12045 PyObject *swig_obj[1] ;
12046
12047 if (!args) SWIG_fail;
12048 swig_obj[0] = args;
12049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12050 if (!SWIG_IsOK(res1)) {
12051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12052 }
12053 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12054 {
12055 PyThreadState* __tstate = wxPyBeginAllowThreads();
12056 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 {
12061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12062 }
12063 return resultobj;
12064 fail:
12065 return NULL;
12066 }
12067
12068
12069 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12070 PyObject *resultobj = 0;
12071 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12072 bool arg2 ;
12073 void *argp1 = 0 ;
12074 int res1 = 0 ;
12075 bool val2 ;
12076 int ecode2 = 0 ;
12077 PyObject * obj0 = 0 ;
12078 PyObject * obj1 = 0 ;
12079 char * kwnames[] = {
12080 (char *) "self",(char *) "bDoPass", NULL
12081 };
12082
12083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12085 if (!SWIG_IsOK(res1)) {
12086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12087 }
12088 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12089 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12090 if (!SWIG_IsOK(ecode2)) {
12091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12092 }
12093 arg2 = static_cast< bool >(val2);
12094 {
12095 PyThreadState* __tstate = wxPyBeginAllowThreads();
12096 (arg1)->PassMessages(arg2);
12097 wxPyEndAllowThreads(__tstate);
12098 if (PyErr_Occurred()) SWIG_fail;
12099 }
12100 resultobj = SWIG_Py_Void();
12101 return resultobj;
12102 fail:
12103 return NULL;
12104 }
12105
12106
12107 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12108 PyObject *obj;
12109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12110 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
12111 return SWIG_Py_Void();
12112 }
12113
12114 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12115 return SWIG_Python_InitShadowInstance(args);
12116 }
12117
12118 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj = 0;
12120 wxLog *arg1 = (wxLog *) 0 ;
12121 wxLogChain *result = 0 ;
12122 void *argp1 = 0 ;
12123 int res1 = 0 ;
12124 PyObject * obj0 = 0 ;
12125 char * kwnames[] = {
12126 (char *) "logger", NULL
12127 };
12128
12129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12131 if (!SWIG_IsOK(res1)) {
12132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12133 }
12134 arg1 = reinterpret_cast< wxLog * >(argp1);
12135 {
12136 PyThreadState* __tstate = wxPyBeginAllowThreads();
12137 result = (wxLogChain *)new wxLogChain(arg1);
12138 wxPyEndAllowThreads(__tstate);
12139 if (PyErr_Occurred()) SWIG_fail;
12140 }
12141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12142 return resultobj;
12143 fail:
12144 return NULL;
12145 }
12146
12147
12148 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12149 PyObject *resultobj = 0;
12150 wxLogChain *arg1 = (wxLogChain *) 0 ;
12151 wxLog *arg2 = (wxLog *) 0 ;
12152 void *argp1 = 0 ;
12153 int res1 = 0 ;
12154 void *argp2 = 0 ;
12155 int res2 = 0 ;
12156 PyObject * obj0 = 0 ;
12157 PyObject * obj1 = 0 ;
12158 char * kwnames[] = {
12159 (char *) "self",(char *) "logger", NULL
12160 };
12161
12162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12164 if (!SWIG_IsOK(res1)) {
12165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12166 }
12167 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12169 if (!SWIG_IsOK(res2)) {
12170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12171 }
12172 arg2 = reinterpret_cast< wxLog * >(argp2);
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 (arg1)->SetLog(arg2);
12176 wxPyEndAllowThreads(__tstate);
12177 if (PyErr_Occurred()) SWIG_fail;
12178 }
12179 resultobj = SWIG_Py_Void();
12180 return resultobj;
12181 fail:
12182 return NULL;
12183 }
12184
12185
12186 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12187 PyObject *resultobj = 0;
12188 wxLogChain *arg1 = (wxLogChain *) 0 ;
12189 bool arg2 ;
12190 void *argp1 = 0 ;
12191 int res1 = 0 ;
12192 bool val2 ;
12193 int ecode2 = 0 ;
12194 PyObject * obj0 = 0 ;
12195 PyObject * obj1 = 0 ;
12196 char * kwnames[] = {
12197 (char *) "self",(char *) "bDoPass", NULL
12198 };
12199
12200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12202 if (!SWIG_IsOK(res1)) {
12203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12204 }
12205 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12206 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12207 if (!SWIG_IsOK(ecode2)) {
12208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12209 }
12210 arg2 = static_cast< bool >(val2);
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 (arg1)->PassMessages(arg2);
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 resultobj = SWIG_Py_Void();
12218 return resultobj;
12219 fail:
12220 return NULL;
12221 }
12222
12223
12224 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12225 PyObject *resultobj = 0;
12226 wxLogChain *arg1 = (wxLogChain *) 0 ;
12227 bool result;
12228 void *argp1 = 0 ;
12229 int res1 = 0 ;
12230 PyObject *swig_obj[1] ;
12231
12232 if (!args) SWIG_fail;
12233 swig_obj[0] = args;
12234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12235 if (!SWIG_IsOK(res1)) {
12236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12237 }
12238 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 result = (bool)(arg1)->IsPassingMessages();
12242 wxPyEndAllowThreads(__tstate);
12243 if (PyErr_Occurred()) SWIG_fail;
12244 }
12245 {
12246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12247 }
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12255 PyObject *resultobj = 0;
12256 wxLogChain *arg1 = (wxLogChain *) 0 ;
12257 wxLog *result = 0 ;
12258 void *argp1 = 0 ;
12259 int res1 = 0 ;
12260 PyObject *swig_obj[1] ;
12261
12262 if (!args) SWIG_fail;
12263 swig_obj[0] = args;
12264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12265 if (!SWIG_IsOK(res1)) {
12266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12267 }
12268 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 result = (wxLog *)(arg1)->GetOldLog();
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12283 PyObject *obj;
12284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12285 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12286 return SWIG_Py_Void();
12287 }
12288
12289 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12290 return SWIG_Python_InitShadowInstance(args);
12291 }
12292
12293 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12294 PyObject *resultobj = 0;
12295 wxLogBuffer *result = 0 ;
12296
12297 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12298 {
12299 PyThreadState* __tstate = wxPyBeginAllowThreads();
12300 result = (wxLogBuffer *)new wxLogBuffer();
12301 wxPyEndAllowThreads(__tstate);
12302 if (PyErr_Occurred()) SWIG_fail;
12303 }
12304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12312 PyObject *resultobj = 0;
12313 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12314 wxString *result = 0 ;
12315 void *argp1 = 0 ;
12316 int res1 = 0 ;
12317 PyObject *swig_obj[1] ;
12318
12319 if (!args) SWIG_fail;
12320 swig_obj[0] = args;
12321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12322 if (!SWIG_IsOK(res1)) {
12323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12324 }
12325 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12326 {
12327 PyThreadState* __tstate = wxPyBeginAllowThreads();
12328 {
12329 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12330 result = (wxString *) &_result_ref;
12331 }
12332 wxPyEndAllowThreads(__tstate);
12333 if (PyErr_Occurred()) SWIG_fail;
12334 }
12335 {
12336 #if wxUSE_UNICODE
12337 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12338 #else
12339 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12340 #endif
12341 }
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12349 PyObject *obj;
12350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12351 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12352 return SWIG_Py_Void();
12353 }
12354
12355 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12356 return SWIG_Python_InitShadowInstance(args);
12357 }
12358
12359 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12360 PyObject *resultobj = 0;
12361 unsigned long result;
12362
12363 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 result = (unsigned long)wxSysErrorCode();
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj = 0;
12379 unsigned long arg1 = (unsigned long) 0 ;
12380 wxString result;
12381 unsigned long val1 ;
12382 int ecode1 = 0 ;
12383 PyObject * obj0 = 0 ;
12384 char * kwnames[] = {
12385 (char *) "nErrCode", NULL
12386 };
12387
12388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12389 if (obj0) {
12390 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12391 if (!SWIG_IsOK(ecode1)) {
12392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12393 }
12394 arg1 = static_cast< unsigned long >(val1);
12395 }
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 result = wxSysErrorMsg(arg1);
12399 wxPyEndAllowThreads(__tstate);
12400 if (PyErr_Occurred()) SWIG_fail;
12401 }
12402 {
12403 #if wxUSE_UNICODE
12404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12405 #else
12406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12407 #endif
12408 }
12409 return resultobj;
12410 fail:
12411 return NULL;
12412 }
12413
12414
12415 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12416 PyObject *resultobj = 0;
12417 wxString *arg1 = 0 ;
12418 bool temp1 = false ;
12419 PyObject * obj0 = 0 ;
12420 char * kwnames[] = {
12421 (char *) "msg", NULL
12422 };
12423
12424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12425 {
12426 arg1 = wxString_in_helper(obj0);
12427 if (arg1 == NULL) SWIG_fail;
12428 temp1 = true;
12429 }
12430 {
12431 PyThreadState* __tstate = wxPyBeginAllowThreads();
12432 wxPyLogFatalError((wxString const &)*arg1);
12433 wxPyEndAllowThreads(__tstate);
12434 if (PyErr_Occurred()) SWIG_fail;
12435 }
12436 resultobj = SWIG_Py_Void();
12437 {
12438 if (temp1)
12439 delete arg1;
12440 }
12441 return resultobj;
12442 fail:
12443 {
12444 if (temp1)
12445 delete arg1;
12446 }
12447 return NULL;
12448 }
12449
12450
12451 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj = 0;
12453 wxString *arg1 = 0 ;
12454 bool temp1 = false ;
12455 PyObject * obj0 = 0 ;
12456 char * kwnames[] = {
12457 (char *) "msg", NULL
12458 };
12459
12460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12461 {
12462 arg1 = wxString_in_helper(obj0);
12463 if (arg1 == NULL) SWIG_fail;
12464 temp1 = true;
12465 }
12466 {
12467 PyThreadState* __tstate = wxPyBeginAllowThreads();
12468 wxPyLogError((wxString const &)*arg1);
12469 wxPyEndAllowThreads(__tstate);
12470 if (PyErr_Occurred()) SWIG_fail;
12471 }
12472 resultobj = SWIG_Py_Void();
12473 {
12474 if (temp1)
12475 delete arg1;
12476 }
12477 return resultobj;
12478 fail:
12479 {
12480 if (temp1)
12481 delete arg1;
12482 }
12483 return NULL;
12484 }
12485
12486
12487 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12488 PyObject *resultobj = 0;
12489 wxString *arg1 = 0 ;
12490 bool temp1 = false ;
12491 PyObject * obj0 = 0 ;
12492 char * kwnames[] = {
12493 (char *) "msg", NULL
12494 };
12495
12496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12497 {
12498 arg1 = wxString_in_helper(obj0);
12499 if (arg1 == NULL) SWIG_fail;
12500 temp1 = true;
12501 }
12502 {
12503 PyThreadState* __tstate = wxPyBeginAllowThreads();
12504 wxPyLogWarning((wxString const &)*arg1);
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 resultobj = SWIG_Py_Void();
12509 {
12510 if (temp1)
12511 delete arg1;
12512 }
12513 return resultobj;
12514 fail:
12515 {
12516 if (temp1)
12517 delete arg1;
12518 }
12519 return NULL;
12520 }
12521
12522
12523 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12524 PyObject *resultobj = 0;
12525 wxString *arg1 = 0 ;
12526 bool temp1 = false ;
12527 PyObject * obj0 = 0 ;
12528 char * kwnames[] = {
12529 (char *) "msg", NULL
12530 };
12531
12532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12533 {
12534 arg1 = wxString_in_helper(obj0);
12535 if (arg1 == NULL) SWIG_fail;
12536 temp1 = true;
12537 }
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 wxPyLogMessage((wxString const &)*arg1);
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 resultobj = SWIG_Py_Void();
12545 {
12546 if (temp1)
12547 delete arg1;
12548 }
12549 return resultobj;
12550 fail:
12551 {
12552 if (temp1)
12553 delete arg1;
12554 }
12555 return NULL;
12556 }
12557
12558
12559 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12560 PyObject *resultobj = 0;
12561 wxString *arg1 = 0 ;
12562 bool temp1 = false ;
12563 PyObject * obj0 = 0 ;
12564 char * kwnames[] = {
12565 (char *) "msg", NULL
12566 };
12567
12568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12569 {
12570 arg1 = wxString_in_helper(obj0);
12571 if (arg1 == NULL) SWIG_fail;
12572 temp1 = true;
12573 }
12574 {
12575 PyThreadState* __tstate = wxPyBeginAllowThreads();
12576 wxPyLogInfo((wxString const &)*arg1);
12577 wxPyEndAllowThreads(__tstate);
12578 if (PyErr_Occurred()) SWIG_fail;
12579 }
12580 resultobj = SWIG_Py_Void();
12581 {
12582 if (temp1)
12583 delete arg1;
12584 }
12585 return resultobj;
12586 fail:
12587 {
12588 if (temp1)
12589 delete arg1;
12590 }
12591 return NULL;
12592 }
12593
12594
12595 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12596 PyObject *resultobj = 0;
12597 wxString *arg1 = 0 ;
12598 bool temp1 = false ;
12599 PyObject * obj0 = 0 ;
12600 char * kwnames[] = {
12601 (char *) "msg", NULL
12602 };
12603
12604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12605 {
12606 arg1 = wxString_in_helper(obj0);
12607 if (arg1 == NULL) SWIG_fail;
12608 temp1 = true;
12609 }
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 wxPyLogDebug((wxString const &)*arg1);
12613 wxPyEndAllowThreads(__tstate);
12614 if (PyErr_Occurred()) SWIG_fail;
12615 }
12616 resultobj = SWIG_Py_Void();
12617 {
12618 if (temp1)
12619 delete arg1;
12620 }
12621 return resultobj;
12622 fail:
12623 {
12624 if (temp1)
12625 delete arg1;
12626 }
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj = 0;
12633 wxString *arg1 = 0 ;
12634 bool temp1 = false ;
12635 PyObject * obj0 = 0 ;
12636 char * kwnames[] = {
12637 (char *) "msg", NULL
12638 };
12639
12640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12641 {
12642 arg1 = wxString_in_helper(obj0);
12643 if (arg1 == NULL) SWIG_fail;
12644 temp1 = true;
12645 }
12646 {
12647 PyThreadState* __tstate = wxPyBeginAllowThreads();
12648 wxPyLogVerbose((wxString const &)*arg1);
12649 wxPyEndAllowThreads(__tstate);
12650 if (PyErr_Occurred()) SWIG_fail;
12651 }
12652 resultobj = SWIG_Py_Void();
12653 {
12654 if (temp1)
12655 delete arg1;
12656 }
12657 return resultobj;
12658 fail:
12659 {
12660 if (temp1)
12661 delete arg1;
12662 }
12663 return NULL;
12664 }
12665
12666
12667 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12668 PyObject *resultobj = 0;
12669 wxString *arg1 = 0 ;
12670 bool temp1 = false ;
12671 PyObject * obj0 = 0 ;
12672 char * kwnames[] = {
12673 (char *) "msg", NULL
12674 };
12675
12676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12677 {
12678 arg1 = wxString_in_helper(obj0);
12679 if (arg1 == NULL) SWIG_fail;
12680 temp1 = true;
12681 }
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 wxPyLogStatus((wxString const &)*arg1);
12685 wxPyEndAllowThreads(__tstate);
12686 if (PyErr_Occurred()) SWIG_fail;
12687 }
12688 resultobj = SWIG_Py_Void();
12689 {
12690 if (temp1)
12691 delete arg1;
12692 }
12693 return resultobj;
12694 fail:
12695 {
12696 if (temp1)
12697 delete arg1;
12698 }
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj = 0;
12705 wxFrame *arg1 = (wxFrame *) 0 ;
12706 wxString *arg2 = 0 ;
12707 void *argp1 = 0 ;
12708 int res1 = 0 ;
12709 bool temp2 = false ;
12710 PyObject * obj0 = 0 ;
12711 PyObject * obj1 = 0 ;
12712 char * kwnames[] = {
12713 (char *) "pFrame",(char *) "msg", NULL
12714 };
12715
12716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12720 }
12721 arg1 = reinterpret_cast< wxFrame * >(argp1);
12722 {
12723 arg2 = wxString_in_helper(obj1);
12724 if (arg2 == NULL) SWIG_fail;
12725 temp2 = true;
12726 }
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12730 wxPyEndAllowThreads(__tstate);
12731 if (PyErr_Occurred()) SWIG_fail;
12732 }
12733 resultobj = SWIG_Py_Void();
12734 {
12735 if (temp2)
12736 delete arg2;
12737 }
12738 return resultobj;
12739 fail:
12740 {
12741 if (temp2)
12742 delete arg2;
12743 }
12744 return NULL;
12745 }
12746
12747
12748 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12749 PyObject *resultobj = 0;
12750 wxString *arg1 = 0 ;
12751 bool temp1 = false ;
12752 PyObject * obj0 = 0 ;
12753 char * kwnames[] = {
12754 (char *) "msg", NULL
12755 };
12756
12757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12758 {
12759 arg1 = wxString_in_helper(obj0);
12760 if (arg1 == NULL) SWIG_fail;
12761 temp1 = true;
12762 }
12763 {
12764 PyThreadState* __tstate = wxPyBeginAllowThreads();
12765 wxPyLogSysError((wxString const &)*arg1);
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 resultobj = SWIG_Py_Void();
12770 {
12771 if (temp1)
12772 delete arg1;
12773 }
12774 return resultobj;
12775 fail:
12776 {
12777 if (temp1)
12778 delete arg1;
12779 }
12780 return NULL;
12781 }
12782
12783
12784 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj = 0;
12786 unsigned long arg1 ;
12787 wxString *arg2 = 0 ;
12788 unsigned long val1 ;
12789 int ecode1 = 0 ;
12790 bool temp2 = false ;
12791 PyObject * obj0 = 0 ;
12792 PyObject * obj1 = 0 ;
12793 char * kwnames[] = {
12794 (char *) "level",(char *) "msg", NULL
12795 };
12796
12797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12798 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12799 if (!SWIG_IsOK(ecode1)) {
12800 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12801 }
12802 arg1 = static_cast< unsigned long >(val1);
12803 {
12804 arg2 = wxString_in_helper(obj1);
12805 if (arg2 == NULL) SWIG_fail;
12806 temp2 = true;
12807 }
12808 {
12809 PyThreadState* __tstate = wxPyBeginAllowThreads();
12810 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12811 wxPyEndAllowThreads(__tstate);
12812 if (PyErr_Occurred()) SWIG_fail;
12813 }
12814 resultobj = SWIG_Py_Void();
12815 {
12816 if (temp2)
12817 delete arg2;
12818 }
12819 return resultobj;
12820 fail:
12821 {
12822 if (temp2)
12823 delete arg2;
12824 }
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12830 PyObject *resultobj = 0;
12831 unsigned long arg1 ;
12832 wxString *arg2 = 0 ;
12833 unsigned long val1 ;
12834 int ecode1 = 0 ;
12835 bool temp2 = false ;
12836
12837 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12838 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12839 if (!SWIG_IsOK(ecode1)) {
12840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12841 }
12842 arg1 = static_cast< unsigned long >(val1);
12843 {
12844 arg2 = wxString_in_helper(swig_obj[1]);
12845 if (arg2 == NULL) SWIG_fail;
12846 temp2 = true;
12847 }
12848 {
12849 PyThreadState* __tstate = wxPyBeginAllowThreads();
12850 wxPyLogTrace(arg1,(wxString const &)*arg2);
12851 wxPyEndAllowThreads(__tstate);
12852 if (PyErr_Occurred()) SWIG_fail;
12853 }
12854 resultobj = SWIG_Py_Void();
12855 {
12856 if (temp2)
12857 delete arg2;
12858 }
12859 return resultobj;
12860 fail:
12861 {
12862 if (temp2)
12863 delete arg2;
12864 }
12865 return NULL;
12866 }
12867
12868
12869 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12870 PyObject *resultobj = 0;
12871 wxString *arg1 = 0 ;
12872 wxString *arg2 = 0 ;
12873 bool temp1 = false ;
12874 bool temp2 = false ;
12875
12876 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12877 {
12878 arg1 = wxString_in_helper(swig_obj[0]);
12879 if (arg1 == NULL) SWIG_fail;
12880 temp1 = true;
12881 }
12882 {
12883 arg2 = wxString_in_helper(swig_obj[1]);
12884 if (arg2 == NULL) SWIG_fail;
12885 temp2 = true;
12886 }
12887 {
12888 PyThreadState* __tstate = wxPyBeginAllowThreads();
12889 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12890 wxPyEndAllowThreads(__tstate);
12891 if (PyErr_Occurred()) SWIG_fail;
12892 }
12893 resultobj = SWIG_Py_Void();
12894 {
12895 if (temp1)
12896 delete arg1;
12897 }
12898 {
12899 if (temp2)
12900 delete arg2;
12901 }
12902 return resultobj;
12903 fail:
12904 {
12905 if (temp1)
12906 delete arg1;
12907 }
12908 {
12909 if (temp2)
12910 delete arg2;
12911 }
12912 return NULL;
12913 }
12914
12915
12916 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12917 int argc;
12918 PyObject *argv[3];
12919
12920 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12921 --argc;
12922 if (argc == 2) {
12923 int _v = 0;
12924 {
12925 {
12926 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12927 }
12928 }
12929 if (!_v) goto check_1;
12930 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12931 }
12932 check_1:
12933
12934 if (argc == 2) {
12935 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12936 }
12937
12938 fail:
12939 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12940 return NULL;
12941 }
12942
12943
12944 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12945 PyObject *resultobj = 0;
12946 wxString *arg1 = 0 ;
12947 wxString *arg2 = 0 ;
12948 bool temp1 = false ;
12949 bool temp2 = false ;
12950 PyObject * obj0 = 0 ;
12951 PyObject * obj1 = 0 ;
12952 char * kwnames[] = {
12953 (char *) "title",(char *) "text", NULL
12954 };
12955
12956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12957 {
12958 arg1 = wxString_in_helper(obj0);
12959 if (arg1 == NULL) SWIG_fail;
12960 temp1 = true;
12961 }
12962 {
12963 arg2 = wxString_in_helper(obj1);
12964 if (arg2 == NULL) SWIG_fail;
12965 temp2 = true;
12966 }
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 resultobj = SWIG_Py_Void();
12974 {
12975 if (temp1)
12976 delete arg1;
12977 }
12978 {
12979 if (temp2)
12980 delete arg2;
12981 }
12982 return resultobj;
12983 fail:
12984 {
12985 if (temp1)
12986 delete arg1;
12987 }
12988 {
12989 if (temp2)
12990 delete arg2;
12991 }
12992 return NULL;
12993 }
12994
12995
12996 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 PyObject *resultobj = 0;
12998 wxLogNull *result = 0 ;
12999
13000 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 result = (wxLogNull *)new wxLogNull();
13004 wxPyEndAllowThreads(__tstate);
13005 if (PyErr_Occurred()) SWIG_fail;
13006 }
13007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 PyObject *resultobj = 0;
13016 wxLogNull *arg1 = (wxLogNull *) 0 ;
13017 void *argp1 = 0 ;
13018 int res1 = 0 ;
13019 PyObject *swig_obj[1] ;
13020
13021 if (!args) SWIG_fail;
13022 swig_obj[0] = args;
13023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13024 if (!SWIG_IsOK(res1)) {
13025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13026 }
13027 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13028 {
13029 PyThreadState* __tstate = wxPyBeginAllowThreads();
13030 delete arg1;
13031
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 resultobj = SWIG_Py_Void();
13036 return resultobj;
13037 fail:
13038 return NULL;
13039 }
13040
13041
13042 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13043 PyObject *obj;
13044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13045 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13046 return SWIG_Py_Void();
13047 }
13048
13049 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13050 return SWIG_Python_InitShadowInstance(args);
13051 }
13052
13053 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13054 PyObject *resultobj = 0;
13055 wxPyLog *result = 0 ;
13056
13057 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
13058 {
13059 PyThreadState* __tstate = wxPyBeginAllowThreads();
13060 result = (wxPyLog *)new wxPyLog();
13061 wxPyEndAllowThreads(__tstate);
13062 if (PyErr_Occurred()) SWIG_fail;
13063 }
13064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13072 PyObject *resultobj = 0;
13073 wxPyLog *arg1 = (wxPyLog *) 0 ;
13074 PyObject *arg2 = (PyObject *) 0 ;
13075 PyObject *arg3 = (PyObject *) 0 ;
13076 void *argp1 = 0 ;
13077 int res1 = 0 ;
13078 PyObject * obj0 = 0 ;
13079 PyObject * obj1 = 0 ;
13080 PyObject * obj2 = 0 ;
13081 char * kwnames[] = {
13082 (char *) "self",(char *) "self",(char *) "_class", NULL
13083 };
13084
13085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
13087 if (!SWIG_IsOK(res1)) {
13088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
13089 }
13090 arg1 = reinterpret_cast< wxPyLog * >(argp1);
13091 arg2 = obj1;
13092 arg3 = obj2;
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 (arg1)->_setCallbackInfo(arg2,arg3);
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 *PyLog_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_wxPyLog, SWIG_NewClientData(obj));
13110 return SWIG_Py_Void();
13111 }
13112
13113 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114 return SWIG_Python_InitShadowInstance(args);
13115 }
13116
13117 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13118 PyObject *resultobj = 0;
13119 int arg1 ;
13120 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13121 int arg3 = (int) wxKILL_NOCHILDREN ;
13122 wxKillError result;
13123 int val1 ;
13124 int ecode1 = 0 ;
13125 int val2 ;
13126 int ecode2 = 0 ;
13127 int val3 ;
13128 int ecode3 = 0 ;
13129 PyObject * obj0 = 0 ;
13130 PyObject * obj1 = 0 ;
13131 PyObject * obj2 = 0 ;
13132 char * kwnames[] = {
13133 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13134 };
13135
13136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13137 ecode1 = SWIG_AsVal_int(obj0, &val1);
13138 if (!SWIG_IsOK(ecode1)) {
13139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13140 }
13141 arg1 = static_cast< int >(val1);
13142 if (obj1) {
13143 ecode2 = SWIG_AsVal_int(obj1, &val2);
13144 if (!SWIG_IsOK(ecode2)) {
13145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13146 }
13147 arg2 = static_cast< wxSignal >(val2);
13148 }
13149 if (obj2) {
13150 ecode3 = SWIG_AsVal_int(obj2, &val3);
13151 if (!SWIG_IsOK(ecode3)) {
13152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13153 }
13154 arg3 = static_cast< int >(val3);
13155 }
13156 {
13157 PyThreadState* __tstate = wxPyBeginAllowThreads();
13158 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13159 wxPyEndAllowThreads(__tstate);
13160 if (PyErr_Occurred()) SWIG_fail;
13161 }
13162 resultobj = SWIG_From_int(static_cast< int >(result));
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj = 0;
13171 int arg1 ;
13172 bool result;
13173 int val1 ;
13174 int ecode1 = 0 ;
13175 PyObject * obj0 = 0 ;
13176 char * kwnames[] = {
13177 (char *) "pid", NULL
13178 };
13179
13180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13181 ecode1 = SWIG_AsVal_int(obj0, &val1);
13182 if (!SWIG_IsOK(ecode1)) {
13183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13184 }
13185 arg1 = static_cast< int >(val1);
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 result = (bool)wxPyProcess::Exists(arg1);
13189 wxPyEndAllowThreads(__tstate);
13190 if (PyErr_Occurred()) SWIG_fail;
13191 }
13192 {
13193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13194 }
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13202 PyObject *resultobj = 0;
13203 wxString *arg1 = 0 ;
13204 int arg2 = (int) wxEXEC_ASYNC ;
13205 wxPyProcess *result = 0 ;
13206 bool temp1 = false ;
13207 int val2 ;
13208 int ecode2 = 0 ;
13209 PyObject * obj0 = 0 ;
13210 PyObject * obj1 = 0 ;
13211 char * kwnames[] = {
13212 (char *) "cmd",(char *) "flags", NULL
13213 };
13214
13215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13216 {
13217 arg1 = wxString_in_helper(obj0);
13218 if (arg1 == NULL) SWIG_fail;
13219 temp1 = true;
13220 }
13221 if (obj1) {
13222 ecode2 = SWIG_AsVal_int(obj1, &val2);
13223 if (!SWIG_IsOK(ecode2)) {
13224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13225 }
13226 arg2 = static_cast< int >(val2);
13227 }
13228 {
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13235 {
13236 if (temp1)
13237 delete arg1;
13238 }
13239 return resultobj;
13240 fail:
13241 {
13242 if (temp1)
13243 delete arg1;
13244 }
13245 return NULL;
13246 }
13247
13248
13249 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13250 PyObject *resultobj = 0;
13251 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13252 int arg2 = (int) -1 ;
13253 wxPyProcess *result = 0 ;
13254 void *argp1 = 0 ;
13255 int res1 = 0 ;
13256 int val2 ;
13257 int ecode2 = 0 ;
13258 PyObject * obj0 = 0 ;
13259 PyObject * obj1 = 0 ;
13260 char * kwnames[] = {
13261 (char *) "parent",(char *) "id", NULL
13262 };
13263
13264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13265 if (obj0) {
13266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13267 if (!SWIG_IsOK(res1)) {
13268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13269 }
13270 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13271 }
13272 if (obj1) {
13273 ecode2 = SWIG_AsVal_int(obj1, &val2);
13274 if (!SWIG_IsOK(ecode2)) {
13275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13276 }
13277 arg2 = static_cast< int >(val2);
13278 }
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13282 wxPyEndAllowThreads(__tstate);
13283 if (PyErr_Occurred()) SWIG_fail;
13284 }
13285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj = 0;
13294 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13295 PyObject *arg2 = (PyObject *) 0 ;
13296 PyObject *arg3 = (PyObject *) 0 ;
13297 void *argp1 = 0 ;
13298 int res1 = 0 ;
13299 PyObject * obj0 = 0 ;
13300 PyObject * obj1 = 0 ;
13301 PyObject * obj2 = 0 ;
13302 char * kwnames[] = {
13303 (char *) "self",(char *) "self",(char *) "_class", NULL
13304 };
13305
13306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13308 if (!SWIG_IsOK(res1)) {
13309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13310 }
13311 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13312 arg2 = obj1;
13313 arg3 = obj2;
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 (arg1)->_setCallbackInfo(arg2,arg3);
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 resultobj = SWIG_Py_Void();
13321 return resultobj;
13322 fail:
13323 return NULL;
13324 }
13325
13326
13327 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13328 PyObject *resultobj = 0;
13329 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13330 int arg2 ;
13331 int arg3 ;
13332 void *argp1 = 0 ;
13333 int res1 = 0 ;
13334 int val2 ;
13335 int ecode2 = 0 ;
13336 int val3 ;
13337 int ecode3 = 0 ;
13338 PyObject * obj0 = 0 ;
13339 PyObject * obj1 = 0 ;
13340 PyObject * obj2 = 0 ;
13341 char * kwnames[] = {
13342 (char *) "self",(char *) "pid",(char *) "status", NULL
13343 };
13344
13345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13347 if (!SWIG_IsOK(res1)) {
13348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13349 }
13350 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13351 ecode2 = SWIG_AsVal_int(obj1, &val2);
13352 if (!SWIG_IsOK(ecode2)) {
13353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13354 }
13355 arg2 = static_cast< int >(val2);
13356 ecode3 = SWIG_AsVal_int(obj2, &val3);
13357 if (!SWIG_IsOK(ecode3)) {
13358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13359 }
13360 arg3 = static_cast< int >(val3);
13361 {
13362 PyThreadState* __tstate = wxPyBeginAllowThreads();
13363 (arg1)->OnTerminate(arg2,arg3);
13364 wxPyEndAllowThreads(__tstate);
13365 if (PyErr_Occurred()) SWIG_fail;
13366 }
13367 resultobj = SWIG_Py_Void();
13368 return resultobj;
13369 fail:
13370 return NULL;
13371 }
13372
13373
13374 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13375 PyObject *resultobj = 0;
13376 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13377 void *argp1 = 0 ;
13378 int res1 = 0 ;
13379 PyObject *swig_obj[1] ;
13380
13381 if (!args) SWIG_fail;
13382 swig_obj[0] = args;
13383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13384 if (!SWIG_IsOK(res1)) {
13385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13386 }
13387 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13388 {
13389 PyThreadState* __tstate = wxPyBeginAllowThreads();
13390 (arg1)->Redirect();
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 resultobj = SWIG_Py_Void();
13395 return resultobj;
13396 fail:
13397 return NULL;
13398 }
13399
13400
13401 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13402 PyObject *resultobj = 0;
13403 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13404 bool result;
13405 void *argp1 = 0 ;
13406 int res1 = 0 ;
13407 PyObject *swig_obj[1] ;
13408
13409 if (!args) SWIG_fail;
13410 swig_obj[0] = args;
13411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13412 if (!SWIG_IsOK(res1)) {
13413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13414 }
13415 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13416 {
13417 PyThreadState* __tstate = wxPyBeginAllowThreads();
13418 result = (bool)(arg1)->IsRedirected();
13419 wxPyEndAllowThreads(__tstate);
13420 if (PyErr_Occurred()) SWIG_fail;
13421 }
13422 {
13423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13424 }
13425 return resultobj;
13426 fail:
13427 return NULL;
13428 }
13429
13430
13431 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432 PyObject *resultobj = 0;
13433 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13434 void *argp1 = 0 ;
13435 int res1 = 0 ;
13436 PyObject *swig_obj[1] ;
13437
13438 if (!args) SWIG_fail;
13439 swig_obj[0] = args;
13440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13441 if (!SWIG_IsOK(res1)) {
13442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13443 }
13444 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13445 {
13446 PyThreadState* __tstate = wxPyBeginAllowThreads();
13447 (arg1)->Detach();
13448 wxPyEndAllowThreads(__tstate);
13449 if (PyErr_Occurred()) SWIG_fail;
13450 }
13451 resultobj = SWIG_Py_Void();
13452 return resultobj;
13453 fail:
13454 return NULL;
13455 }
13456
13457
13458 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13459 PyObject *resultobj = 0;
13460 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13461 wxInputStream *result = 0 ;
13462 void *argp1 = 0 ;
13463 int res1 = 0 ;
13464 PyObject *swig_obj[1] ;
13465
13466 if (!args) SWIG_fail;
13467 swig_obj[0] = args;
13468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13469 if (!SWIG_IsOK(res1)) {
13470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13471 }
13472 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 result = (wxInputStream *)(arg1)->GetInputStream();
13476 wxPyEndAllowThreads(__tstate);
13477 if (PyErr_Occurred()) SWIG_fail;
13478 }
13479 {
13480 wxPyInputStream * _ptr = NULL;
13481
13482 if (result) {
13483 _ptr = new wxPyInputStream(result);
13484 }
13485 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13486 }
13487 return resultobj;
13488 fail:
13489 return NULL;
13490 }
13491
13492
13493 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13494 PyObject *resultobj = 0;
13495 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13496 wxInputStream *result = 0 ;
13497 void *argp1 = 0 ;
13498 int res1 = 0 ;
13499 PyObject *swig_obj[1] ;
13500
13501 if (!args) SWIG_fail;
13502 swig_obj[0] = args;
13503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13504 if (!SWIG_IsOK(res1)) {
13505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13506 }
13507 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13508 {
13509 PyThreadState* __tstate = wxPyBeginAllowThreads();
13510 result = (wxInputStream *)(arg1)->GetErrorStream();
13511 wxPyEndAllowThreads(__tstate);
13512 if (PyErr_Occurred()) SWIG_fail;
13513 }
13514 {
13515 wxPyInputStream * _ptr = NULL;
13516
13517 if (result) {
13518 _ptr = new wxPyInputStream(result);
13519 }
13520 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13521 }
13522 return resultobj;
13523 fail:
13524 return NULL;
13525 }
13526
13527
13528 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13529 PyObject *resultobj = 0;
13530 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13531 wxOutputStream *result = 0 ;
13532 void *argp1 = 0 ;
13533 int res1 = 0 ;
13534 PyObject *swig_obj[1] ;
13535
13536 if (!args) SWIG_fail;
13537 swig_obj[0] = args;
13538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13539 if (!SWIG_IsOK(res1)) {
13540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13541 }
13542 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13543 {
13544 PyThreadState* __tstate = wxPyBeginAllowThreads();
13545 result = (wxOutputStream *)(arg1)->GetOutputStream();
13546 wxPyEndAllowThreads(__tstate);
13547 if (PyErr_Occurred()) SWIG_fail;
13548 }
13549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13550 return resultobj;
13551 fail:
13552 return NULL;
13553 }
13554
13555
13556 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13557 PyObject *resultobj = 0;
13558 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13559 void *argp1 = 0 ;
13560 int res1 = 0 ;
13561 PyObject *swig_obj[1] ;
13562
13563 if (!args) SWIG_fail;
13564 swig_obj[0] = args;
13565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13566 if (!SWIG_IsOK(res1)) {
13567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13568 }
13569 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13570 {
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 (arg1)->CloseOutput();
13573 wxPyEndAllowThreads(__tstate);
13574 if (PyErr_Occurred()) SWIG_fail;
13575 }
13576 resultobj = SWIG_Py_Void();
13577 return resultobj;
13578 fail:
13579 return NULL;
13580 }
13581
13582
13583 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13584 PyObject *resultobj = 0;
13585 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13586 bool result;
13587 void *argp1 = 0 ;
13588 int res1 = 0 ;
13589 PyObject *swig_obj[1] ;
13590
13591 if (!args) SWIG_fail;
13592 swig_obj[0] = args;
13593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13594 if (!SWIG_IsOK(res1)) {
13595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13596 }
13597 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13598 {
13599 PyThreadState* __tstate = wxPyBeginAllowThreads();
13600 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13601 wxPyEndAllowThreads(__tstate);
13602 if (PyErr_Occurred()) SWIG_fail;
13603 }
13604 {
13605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13606 }
13607 return resultobj;
13608 fail:
13609 return NULL;
13610 }
13611
13612
13613 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13614 PyObject *resultobj = 0;
13615 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13616 bool result;
13617 void *argp1 = 0 ;
13618 int res1 = 0 ;
13619 PyObject *swig_obj[1] ;
13620
13621 if (!args) SWIG_fail;
13622 swig_obj[0] = args;
13623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13624 if (!SWIG_IsOK(res1)) {
13625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13626 }
13627 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 {
13635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13636 }
13637 return resultobj;
13638 fail:
13639 return NULL;
13640 }
13641
13642
13643 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13644 PyObject *resultobj = 0;
13645 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13646 bool result;
13647 void *argp1 = 0 ;
13648 int res1 = 0 ;
13649 PyObject *swig_obj[1] ;
13650
13651 if (!args) SWIG_fail;
13652 swig_obj[0] = args;
13653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13654 if (!SWIG_IsOK(res1)) {
13655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13656 }
13657 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13658 {
13659 PyThreadState* __tstate = wxPyBeginAllowThreads();
13660 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13661 wxPyEndAllowThreads(__tstate);
13662 if (PyErr_Occurred()) SWIG_fail;
13663 }
13664 {
13665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13666 }
13667 return resultobj;
13668 fail:
13669 return NULL;
13670 }
13671
13672
13673 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13674 PyObject *obj;
13675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13676 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13677 return SWIG_Py_Void();
13678 }
13679
13680 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13681 return SWIG_Python_InitShadowInstance(args);
13682 }
13683
13684 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj = 0;
13686 int arg1 = (int) 0 ;
13687 int arg2 = (int) 0 ;
13688 int arg3 = (int) 0 ;
13689 wxProcessEvent *result = 0 ;
13690 int val1 ;
13691 int ecode1 = 0 ;
13692 int val2 ;
13693 int ecode2 = 0 ;
13694 int val3 ;
13695 int ecode3 = 0 ;
13696 PyObject * obj0 = 0 ;
13697 PyObject * obj1 = 0 ;
13698 PyObject * obj2 = 0 ;
13699 char * kwnames[] = {
13700 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13701 };
13702
13703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13704 if (obj0) {
13705 ecode1 = SWIG_AsVal_int(obj0, &val1);
13706 if (!SWIG_IsOK(ecode1)) {
13707 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13708 }
13709 arg1 = static_cast< int >(val1);
13710 }
13711 if (obj1) {
13712 ecode2 = SWIG_AsVal_int(obj1, &val2);
13713 if (!SWIG_IsOK(ecode2)) {
13714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13715 }
13716 arg2 = static_cast< int >(val2);
13717 }
13718 if (obj2) {
13719 ecode3 = SWIG_AsVal_int(obj2, &val3);
13720 if (!SWIG_IsOK(ecode3)) {
13721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13722 }
13723 arg3 = static_cast< int >(val3);
13724 }
13725 {
13726 PyThreadState* __tstate = wxPyBeginAllowThreads();
13727 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13728 wxPyEndAllowThreads(__tstate);
13729 if (PyErr_Occurred()) SWIG_fail;
13730 }
13731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13732 return resultobj;
13733 fail:
13734 return NULL;
13735 }
13736
13737
13738 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13739 PyObject *resultobj = 0;
13740 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13741 int result;
13742 void *argp1 = 0 ;
13743 int res1 = 0 ;
13744 PyObject *swig_obj[1] ;
13745
13746 if (!args) SWIG_fail;
13747 swig_obj[0] = args;
13748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13749 if (!SWIG_IsOK(res1)) {
13750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13751 }
13752 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13753 {
13754 PyThreadState* __tstate = wxPyBeginAllowThreads();
13755 result = (int)(arg1)->GetPid();
13756 wxPyEndAllowThreads(__tstate);
13757 if (PyErr_Occurred()) SWIG_fail;
13758 }
13759 resultobj = SWIG_From_int(static_cast< int >(result));
13760 return resultobj;
13761 fail:
13762 return NULL;
13763 }
13764
13765
13766 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13767 PyObject *resultobj = 0;
13768 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13769 int result;
13770 void *argp1 = 0 ;
13771 int res1 = 0 ;
13772 PyObject *swig_obj[1] ;
13773
13774 if (!args) SWIG_fail;
13775 swig_obj[0] = args;
13776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13777 if (!SWIG_IsOK(res1)) {
13778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13779 }
13780 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13781 {
13782 PyThreadState* __tstate = wxPyBeginAllowThreads();
13783 result = (int)(arg1)->GetExitCode();
13784 wxPyEndAllowThreads(__tstate);
13785 if (PyErr_Occurred()) SWIG_fail;
13786 }
13787 resultobj = SWIG_From_int(static_cast< int >(result));
13788 return resultobj;
13789 fail:
13790 return NULL;
13791 }
13792
13793
13794 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13795 PyObject *resultobj = 0;
13796 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13797 int arg2 ;
13798 void *argp1 = 0 ;
13799 int res1 = 0 ;
13800 int val2 ;
13801 int ecode2 = 0 ;
13802 PyObject *swig_obj[2] ;
13803
13804 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13806 if (!SWIG_IsOK(res1)) {
13807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13808 }
13809 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13810 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13811 if (!SWIG_IsOK(ecode2)) {
13812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13813 }
13814 arg2 = static_cast< int >(val2);
13815 if (arg1) (arg1)->m_pid = arg2;
13816
13817 resultobj = SWIG_Py_Void();
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13825 PyObject *resultobj = 0;
13826 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13827 int result;
13828 void *argp1 = 0 ;
13829 int res1 = 0 ;
13830 PyObject *swig_obj[1] ;
13831
13832 if (!args) SWIG_fail;
13833 swig_obj[0] = args;
13834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13835 if (!SWIG_IsOK(res1)) {
13836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13837 }
13838 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13839 result = (int) ((arg1)->m_pid);
13840 resultobj = SWIG_From_int(static_cast< int >(result));
13841 return resultobj;
13842 fail:
13843 return NULL;
13844 }
13845
13846
13847 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13848 PyObject *resultobj = 0;
13849 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13850 int arg2 ;
13851 void *argp1 = 0 ;
13852 int res1 = 0 ;
13853 int val2 ;
13854 int ecode2 = 0 ;
13855 PyObject *swig_obj[2] ;
13856
13857 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13859 if (!SWIG_IsOK(res1)) {
13860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13861 }
13862 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13863 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13864 if (!SWIG_IsOK(ecode2)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13866 }
13867 arg2 = static_cast< int >(val2);
13868 if (arg1) (arg1)->m_exitcode = arg2;
13869
13870 resultobj = SWIG_Py_Void();
13871 return resultobj;
13872 fail:
13873 return NULL;
13874 }
13875
13876
13877 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13878 PyObject *resultobj = 0;
13879 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13880 int result;
13881 void *argp1 = 0 ;
13882 int res1 = 0 ;
13883 PyObject *swig_obj[1] ;
13884
13885 if (!args) SWIG_fail;
13886 swig_obj[0] = args;
13887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13888 if (!SWIG_IsOK(res1)) {
13889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13890 }
13891 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13892 result = (int) ((arg1)->m_exitcode);
13893 resultobj = SWIG_From_int(static_cast< int >(result));
13894 return resultobj;
13895 fail:
13896 return NULL;
13897 }
13898
13899
13900 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13901 PyObject *obj;
13902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13903 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13904 return SWIG_Py_Void();
13905 }
13906
13907 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13908 return SWIG_Python_InitShadowInstance(args);
13909 }
13910
13911 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13912 PyObject *resultobj = 0;
13913 wxString *arg1 = 0 ;
13914 int arg2 = (int) wxEXEC_ASYNC ;
13915 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13916 long result;
13917 bool temp1 = false ;
13918 int val2 ;
13919 int ecode2 = 0 ;
13920 void *argp3 = 0 ;
13921 int res3 = 0 ;
13922 PyObject * obj0 = 0 ;
13923 PyObject * obj1 = 0 ;
13924 PyObject * obj2 = 0 ;
13925 char * kwnames[] = {
13926 (char *) "command",(char *) "flags",(char *) "process", NULL
13927 };
13928
13929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13930 {
13931 arg1 = wxString_in_helper(obj0);
13932 if (arg1 == NULL) SWIG_fail;
13933 temp1 = true;
13934 }
13935 if (obj1) {
13936 ecode2 = SWIG_AsVal_int(obj1, &val2);
13937 if (!SWIG_IsOK(ecode2)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13939 }
13940 arg2 = static_cast< int >(val2);
13941 }
13942 if (obj2) {
13943 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13944 if (!SWIG_IsOK(res3)) {
13945 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13946 }
13947 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13948 }
13949 {
13950 if (!wxPyCheckForApp()) SWIG_fail;
13951 PyThreadState* __tstate = wxPyBeginAllowThreads();
13952 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13953 wxPyEndAllowThreads(__tstate);
13954 if (PyErr_Occurred()) SWIG_fail;
13955 }
13956 resultobj = SWIG_From_long(static_cast< long >(result));
13957 {
13958 if (temp1)
13959 delete arg1;
13960 }
13961 return resultobj;
13962 fail:
13963 {
13964 if (temp1)
13965 delete arg1;
13966 }
13967 return NULL;
13968 }
13969
13970
13971 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13972 PyObject *resultobj = 0;
13973 long arg1 ;
13974 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13975 wxKillError *arg3 = (wxKillError *) 0 ;
13976 int arg4 = (int) wxKILL_NOCHILDREN ;
13977 int result;
13978 long val1 ;
13979 int ecode1 = 0 ;
13980 int val2 ;
13981 int ecode2 = 0 ;
13982 wxKillError temp3 ;
13983 int val4 ;
13984 int ecode4 = 0 ;
13985 PyObject * obj0 = 0 ;
13986 PyObject * obj1 = 0 ;
13987 PyObject * obj2 = 0 ;
13988 char * kwnames[] = {
13989 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13990 };
13991
13992 {
13993 arg3 = &temp3;
13994 }
13995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13996 ecode1 = SWIG_AsVal_long(obj0, &val1);
13997 if (!SWIG_IsOK(ecode1)) {
13998 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13999 }
14000 arg1 = static_cast< long >(val1);
14001 if (obj1) {
14002 ecode2 = SWIG_AsVal_int(obj1, &val2);
14003 if (!SWIG_IsOK(ecode2)) {
14004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14005 }
14006 arg2 = static_cast< wxSignal >(val2);
14007 }
14008 if (obj2) {
14009 ecode4 = SWIG_AsVal_int(obj2, &val4);
14010 if (!SWIG_IsOK(ecode4)) {
14011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14012 }
14013 arg4 = static_cast< int >(val4);
14014 }
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 result = (int)wxKill(arg1,arg2,arg3,arg4);
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 resultobj = SWIG_From_int(static_cast< int >(result));
14022 {
14023 PyObject* o;
14024 o = PyInt_FromLong((long) (*arg3));
14025
14026
14027
14028 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14029
14030 }
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj = 0;
14039 int arg1 = (int) wxJOYSTICK1 ;
14040 wxJoystick *result = 0 ;
14041 int val1 ;
14042 int ecode1 = 0 ;
14043 PyObject * obj0 = 0 ;
14044 char * kwnames[] = {
14045 (char *) "joystick", NULL
14046 };
14047
14048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14049 if (obj0) {
14050 ecode1 = SWIG_AsVal_int(obj0, &val1);
14051 if (!SWIG_IsOK(ecode1)) {
14052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
14053 }
14054 arg1 = static_cast< int >(val1);
14055 }
14056 {
14057 if (!wxPyCheckForApp()) SWIG_fail;
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 result = (wxJoystick *)new wxJoystick(arg1);
14060 wxPyEndAllowThreads(__tstate);
14061 if (PyErr_Occurred()) SWIG_fail;
14062 }
14063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
14064 return resultobj;
14065 fail:
14066 return NULL;
14067 }
14068
14069
14070 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14071 PyObject *resultobj = 0;
14072 wxJoystick *arg1 = (wxJoystick *) 0 ;
14073 void *argp1 = 0 ;
14074 int res1 = 0 ;
14075 PyObject *swig_obj[1] ;
14076
14077 if (!args) SWIG_fail;
14078 swig_obj[0] = args;
14079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
14080 if (!SWIG_IsOK(res1)) {
14081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
14082 }
14083 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14084 {
14085 PyThreadState* __tstate = wxPyBeginAllowThreads();
14086 delete arg1;
14087
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 resultobj = SWIG_Py_Void();
14092 return resultobj;
14093 fail:
14094 return NULL;
14095 }
14096
14097
14098 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14099 PyObject *resultobj = 0;
14100 wxJoystick *arg1 = (wxJoystick *) 0 ;
14101 wxPoint result;
14102 void *argp1 = 0 ;
14103 int res1 = 0 ;
14104 PyObject *swig_obj[1] ;
14105
14106 if (!args) SWIG_fail;
14107 swig_obj[0] = args;
14108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14109 if (!SWIG_IsOK(res1)) {
14110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14111 }
14112 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14113 {
14114 PyThreadState* __tstate = wxPyBeginAllowThreads();
14115 result = (arg1)->GetPosition();
14116 wxPyEndAllowThreads(__tstate);
14117 if (PyErr_Occurred()) SWIG_fail;
14118 }
14119 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14120 return resultobj;
14121 fail:
14122 return NULL;
14123 }
14124
14125
14126 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14127 PyObject *resultobj = 0;
14128 wxJoystick *arg1 = (wxJoystick *) 0 ;
14129 int result;
14130 void *argp1 = 0 ;
14131 int res1 = 0 ;
14132 PyObject *swig_obj[1] ;
14133
14134 if (!args) SWIG_fail;
14135 swig_obj[0] = args;
14136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14137 if (!SWIG_IsOK(res1)) {
14138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14139 }
14140 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14141 {
14142 PyThreadState* __tstate = wxPyBeginAllowThreads();
14143 result = (int)(arg1)->GetZPosition();
14144 wxPyEndAllowThreads(__tstate);
14145 if (PyErr_Occurred()) SWIG_fail;
14146 }
14147 resultobj = SWIG_From_int(static_cast< int >(result));
14148 return resultobj;
14149 fail:
14150 return NULL;
14151 }
14152
14153
14154 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14155 PyObject *resultobj = 0;
14156 wxJoystick *arg1 = (wxJoystick *) 0 ;
14157 int result;
14158 void *argp1 = 0 ;
14159 int res1 = 0 ;
14160 PyObject *swig_obj[1] ;
14161
14162 if (!args) SWIG_fail;
14163 swig_obj[0] = args;
14164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14167 }
14168 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14169 {
14170 PyThreadState* __tstate = wxPyBeginAllowThreads();
14171 result = (int)(arg1)->GetButtonState();
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 resultobj = SWIG_From_int(static_cast< int >(result));
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14183 PyObject *resultobj = 0;
14184 wxJoystick *arg1 = (wxJoystick *) 0 ;
14185 int result;
14186 void *argp1 = 0 ;
14187 int res1 = 0 ;
14188 PyObject *swig_obj[1] ;
14189
14190 if (!args) SWIG_fail;
14191 swig_obj[0] = args;
14192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14193 if (!SWIG_IsOK(res1)) {
14194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14195 }
14196 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 result = (int)(arg1)->GetPOVPosition();
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 resultobj = SWIG_From_int(static_cast< int >(result));
14204 return resultobj;
14205 fail:
14206 return NULL;
14207 }
14208
14209
14210 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14211 PyObject *resultobj = 0;
14212 wxJoystick *arg1 = (wxJoystick *) 0 ;
14213 int result;
14214 void *argp1 = 0 ;
14215 int res1 = 0 ;
14216 PyObject *swig_obj[1] ;
14217
14218 if (!args) SWIG_fail;
14219 swig_obj[0] = args;
14220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14221 if (!SWIG_IsOK(res1)) {
14222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14223 }
14224 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14225 {
14226 PyThreadState* __tstate = wxPyBeginAllowThreads();
14227 result = (int)(arg1)->GetPOVCTSPosition();
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 resultobj = SWIG_From_int(static_cast< int >(result));
14232 return resultobj;
14233 fail:
14234 return NULL;
14235 }
14236
14237
14238 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14239 PyObject *resultobj = 0;
14240 wxJoystick *arg1 = (wxJoystick *) 0 ;
14241 int result;
14242 void *argp1 = 0 ;
14243 int res1 = 0 ;
14244 PyObject *swig_obj[1] ;
14245
14246 if (!args) SWIG_fail;
14247 swig_obj[0] = args;
14248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14249 if (!SWIG_IsOK(res1)) {
14250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14251 }
14252 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14253 {
14254 PyThreadState* __tstate = wxPyBeginAllowThreads();
14255 result = (int)(arg1)->GetRudderPosition();
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 resultobj = SWIG_From_int(static_cast< int >(result));
14260 return resultobj;
14261 fail:
14262 return NULL;
14263 }
14264
14265
14266 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14267 PyObject *resultobj = 0;
14268 wxJoystick *arg1 = (wxJoystick *) 0 ;
14269 int result;
14270 void *argp1 = 0 ;
14271 int res1 = 0 ;
14272 PyObject *swig_obj[1] ;
14273
14274 if (!args) SWIG_fail;
14275 swig_obj[0] = args;
14276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14277 if (!SWIG_IsOK(res1)) {
14278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14279 }
14280 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 result = (int)(arg1)->GetUPosition();
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 resultobj = SWIG_From_int(static_cast< int >(result));
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14295 PyObject *resultobj = 0;
14296 wxJoystick *arg1 = (wxJoystick *) 0 ;
14297 int result;
14298 void *argp1 = 0 ;
14299 int res1 = 0 ;
14300 PyObject *swig_obj[1] ;
14301
14302 if (!args) SWIG_fail;
14303 swig_obj[0] = args;
14304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14305 if (!SWIG_IsOK(res1)) {
14306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14307 }
14308 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14309 {
14310 PyThreadState* __tstate = wxPyBeginAllowThreads();
14311 result = (int)(arg1)->GetVPosition();
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 resultobj = SWIG_From_int(static_cast< int >(result));
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14323 PyObject *resultobj = 0;
14324 wxJoystick *arg1 = (wxJoystick *) 0 ;
14325 int result;
14326 void *argp1 = 0 ;
14327 int res1 = 0 ;
14328 PyObject *swig_obj[1] ;
14329
14330 if (!args) SWIG_fail;
14331 swig_obj[0] = args;
14332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14333 if (!SWIG_IsOK(res1)) {
14334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14335 }
14336 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 result = (int)(arg1)->GetMovementThreshold();
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 resultobj = SWIG_From_int(static_cast< int >(result));
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj = 0;
14352 wxJoystick *arg1 = (wxJoystick *) 0 ;
14353 int arg2 ;
14354 void *argp1 = 0 ;
14355 int res1 = 0 ;
14356 int val2 ;
14357 int ecode2 = 0 ;
14358 PyObject * obj0 = 0 ;
14359 PyObject * obj1 = 0 ;
14360 char * kwnames[] = {
14361 (char *) "self",(char *) "threshold", NULL
14362 };
14363
14364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14366 if (!SWIG_IsOK(res1)) {
14367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14368 }
14369 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14370 ecode2 = SWIG_AsVal_int(obj1, &val2);
14371 if (!SWIG_IsOK(ecode2)) {
14372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14373 }
14374 arg2 = static_cast< int >(val2);
14375 {
14376 PyThreadState* __tstate = wxPyBeginAllowThreads();
14377 (arg1)->SetMovementThreshold(arg2);
14378 wxPyEndAllowThreads(__tstate);
14379 if (PyErr_Occurred()) SWIG_fail;
14380 }
14381 resultobj = SWIG_Py_Void();
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14389 PyObject *resultobj = 0;
14390 wxJoystick *arg1 = (wxJoystick *) 0 ;
14391 bool result;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 PyObject *swig_obj[1] ;
14395
14396 if (!args) SWIG_fail;
14397 swig_obj[0] = args;
14398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14399 if (!SWIG_IsOK(res1)) {
14400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14401 }
14402 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 result = (bool)(arg1)->IsOk();
14406 wxPyEndAllowThreads(__tstate);
14407 if (PyErr_Occurred()) SWIG_fail;
14408 }
14409 {
14410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14411 }
14412 return resultobj;
14413 fail:
14414 return NULL;
14415 }
14416
14417
14418 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14419 PyObject *resultobj = 0;
14420 wxJoystick *arg1 = (wxJoystick *) 0 ;
14421 int result;
14422 void *argp1 = 0 ;
14423 int res1 = 0 ;
14424 PyObject *swig_obj[1] ;
14425
14426 if (!args) SWIG_fail;
14427 swig_obj[0] = args;
14428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14431 }
14432 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14433 {
14434 PyThreadState* __tstate = wxPyBeginAllowThreads();
14435 result = (int)(arg1)->GetNumberJoysticks();
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 resultobj = SWIG_From_int(static_cast< int >(result));
14440 return resultobj;
14441 fail:
14442 return NULL;
14443 }
14444
14445
14446 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14447 PyObject *resultobj = 0;
14448 wxJoystick *arg1 = (wxJoystick *) 0 ;
14449 int result;
14450 void *argp1 = 0 ;
14451 int res1 = 0 ;
14452 PyObject *swig_obj[1] ;
14453
14454 if (!args) SWIG_fail;
14455 swig_obj[0] = args;
14456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14457 if (!SWIG_IsOK(res1)) {
14458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14459 }
14460 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (int)(arg1)->GetManufacturerId();
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 resultobj = SWIG_From_int(static_cast< int >(result));
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14475 PyObject *resultobj = 0;
14476 wxJoystick *arg1 = (wxJoystick *) 0 ;
14477 int result;
14478 void *argp1 = 0 ;
14479 int res1 = 0 ;
14480 PyObject *swig_obj[1] ;
14481
14482 if (!args) SWIG_fail;
14483 swig_obj[0] = args;
14484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14485 if (!SWIG_IsOK(res1)) {
14486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14487 }
14488 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14489 {
14490 PyThreadState* __tstate = wxPyBeginAllowThreads();
14491 result = (int)(arg1)->GetProductId();
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 resultobj = SWIG_From_int(static_cast< int >(result));
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14503 PyObject *resultobj = 0;
14504 wxJoystick *arg1 = (wxJoystick *) 0 ;
14505 wxString result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 PyObject *swig_obj[1] ;
14509
14510 if (!args) SWIG_fail;
14511 swig_obj[0] = args;
14512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14513 if (!SWIG_IsOK(res1)) {
14514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14515 }
14516 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (arg1)->GetProductName();
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 {
14524 #if wxUSE_UNICODE
14525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14526 #else
14527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14528 #endif
14529 }
14530 return resultobj;
14531 fail:
14532 return NULL;
14533 }
14534
14535
14536 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14537 PyObject *resultobj = 0;
14538 wxJoystick *arg1 = (wxJoystick *) 0 ;
14539 int result;
14540 void *argp1 = 0 ;
14541 int res1 = 0 ;
14542 PyObject *swig_obj[1] ;
14543
14544 if (!args) SWIG_fail;
14545 swig_obj[0] = args;
14546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14547 if (!SWIG_IsOK(res1)) {
14548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14549 }
14550 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14551 {
14552 PyThreadState* __tstate = wxPyBeginAllowThreads();
14553 result = (int)(arg1)->GetXMin();
14554 wxPyEndAllowThreads(__tstate);
14555 if (PyErr_Occurred()) SWIG_fail;
14556 }
14557 resultobj = SWIG_From_int(static_cast< int >(result));
14558 return resultobj;
14559 fail:
14560 return NULL;
14561 }
14562
14563
14564 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14565 PyObject *resultobj = 0;
14566 wxJoystick *arg1 = (wxJoystick *) 0 ;
14567 int result;
14568 void *argp1 = 0 ;
14569 int res1 = 0 ;
14570 PyObject *swig_obj[1] ;
14571
14572 if (!args) SWIG_fail;
14573 swig_obj[0] = args;
14574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14575 if (!SWIG_IsOK(res1)) {
14576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14577 }
14578 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14579 {
14580 PyThreadState* __tstate = wxPyBeginAllowThreads();
14581 result = (int)(arg1)->GetYMin();
14582 wxPyEndAllowThreads(__tstate);
14583 if (PyErr_Occurred()) SWIG_fail;
14584 }
14585 resultobj = SWIG_From_int(static_cast< int >(result));
14586 return resultobj;
14587 fail:
14588 return NULL;
14589 }
14590
14591
14592 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14593 PyObject *resultobj = 0;
14594 wxJoystick *arg1 = (wxJoystick *) 0 ;
14595 int result;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 PyObject *swig_obj[1] ;
14599
14600 if (!args) SWIG_fail;
14601 swig_obj[0] = args;
14602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14603 if (!SWIG_IsOK(res1)) {
14604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14605 }
14606 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 result = (int)(arg1)->GetZMin();
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 resultobj = SWIG_From_int(static_cast< int >(result));
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14621 PyObject *resultobj = 0;
14622 wxJoystick *arg1 = (wxJoystick *) 0 ;
14623 int result;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 PyObject *swig_obj[1] ;
14627
14628 if (!args) SWIG_fail;
14629 swig_obj[0] = args;
14630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14631 if (!SWIG_IsOK(res1)) {
14632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14633 }
14634 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14635 {
14636 PyThreadState* __tstate = wxPyBeginAllowThreads();
14637 result = (int)(arg1)->GetXMax();
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 resultobj = SWIG_From_int(static_cast< int >(result));
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14649 PyObject *resultobj = 0;
14650 wxJoystick *arg1 = (wxJoystick *) 0 ;
14651 int result;
14652 void *argp1 = 0 ;
14653 int res1 = 0 ;
14654 PyObject *swig_obj[1] ;
14655
14656 if (!args) SWIG_fail;
14657 swig_obj[0] = args;
14658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14659 if (!SWIG_IsOK(res1)) {
14660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14661 }
14662 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (int)(arg1)->GetYMax();
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 resultobj = SWIG_From_int(static_cast< int >(result));
14670 return resultobj;
14671 fail:
14672 return NULL;
14673 }
14674
14675
14676 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14677 PyObject *resultobj = 0;
14678 wxJoystick *arg1 = (wxJoystick *) 0 ;
14679 int result;
14680 void *argp1 = 0 ;
14681 int res1 = 0 ;
14682 PyObject *swig_obj[1] ;
14683
14684 if (!args) SWIG_fail;
14685 swig_obj[0] = args;
14686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14687 if (!SWIG_IsOK(res1)) {
14688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14689 }
14690 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 result = (int)(arg1)->GetZMax();
14694 wxPyEndAllowThreads(__tstate);
14695 if (PyErr_Occurred()) SWIG_fail;
14696 }
14697 resultobj = SWIG_From_int(static_cast< int >(result));
14698 return resultobj;
14699 fail:
14700 return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14705 PyObject *resultobj = 0;
14706 wxJoystick *arg1 = (wxJoystick *) 0 ;
14707 int result;
14708 void *argp1 = 0 ;
14709 int res1 = 0 ;
14710 PyObject *swig_obj[1] ;
14711
14712 if (!args) SWIG_fail;
14713 swig_obj[0] = args;
14714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14715 if (!SWIG_IsOK(res1)) {
14716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14717 }
14718 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (int)(arg1)->GetNumberButtons();
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 resultobj = SWIG_From_int(static_cast< int >(result));
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxJoystick *arg1 = (wxJoystick *) 0 ;
14735 int result;
14736 void *argp1 = 0 ;
14737 int res1 = 0 ;
14738 PyObject *swig_obj[1] ;
14739
14740 if (!args) SWIG_fail;
14741 swig_obj[0] = args;
14742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14745 }
14746 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 result = (int)(arg1)->GetNumberAxes();
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 resultobj = SWIG_From_int(static_cast< int >(result));
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14761 PyObject *resultobj = 0;
14762 wxJoystick *arg1 = (wxJoystick *) 0 ;
14763 int result;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 PyObject *swig_obj[1] ;
14767
14768 if (!args) SWIG_fail;
14769 swig_obj[0] = args;
14770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14771 if (!SWIG_IsOK(res1)) {
14772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14773 }
14774 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (int)(arg1)->GetMaxButtons();
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 resultobj = SWIG_From_int(static_cast< int >(result));
14782 return resultobj;
14783 fail:
14784 return NULL;
14785 }
14786
14787
14788 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14789 PyObject *resultobj = 0;
14790 wxJoystick *arg1 = (wxJoystick *) 0 ;
14791 int result;
14792 void *argp1 = 0 ;
14793 int res1 = 0 ;
14794 PyObject *swig_obj[1] ;
14795
14796 if (!args) SWIG_fail;
14797 swig_obj[0] = args;
14798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14799 if (!SWIG_IsOK(res1)) {
14800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14801 }
14802 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 result = (int)(arg1)->GetMaxAxes();
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 resultobj = SWIG_From_int(static_cast< int >(result));
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14817 PyObject *resultobj = 0;
14818 wxJoystick *arg1 = (wxJoystick *) 0 ;
14819 int result;
14820 void *argp1 = 0 ;
14821 int res1 = 0 ;
14822 PyObject *swig_obj[1] ;
14823
14824 if (!args) SWIG_fail;
14825 swig_obj[0] = args;
14826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14829 }
14830 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14831 {
14832 PyThreadState* __tstate = wxPyBeginAllowThreads();
14833 result = (int)(arg1)->GetPollingMin();
14834 wxPyEndAllowThreads(__tstate);
14835 if (PyErr_Occurred()) SWIG_fail;
14836 }
14837 resultobj = SWIG_From_int(static_cast< int >(result));
14838 return resultobj;
14839 fail:
14840 return NULL;
14841 }
14842
14843
14844 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14845 PyObject *resultobj = 0;
14846 wxJoystick *arg1 = (wxJoystick *) 0 ;
14847 int result;
14848 void *argp1 = 0 ;
14849 int res1 = 0 ;
14850 PyObject *swig_obj[1] ;
14851
14852 if (!args) SWIG_fail;
14853 swig_obj[0] = args;
14854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14855 if (!SWIG_IsOK(res1)) {
14856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14857 }
14858 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (int)(arg1)->GetPollingMax();
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 resultobj = SWIG_From_int(static_cast< int >(result));
14866 return resultobj;
14867 fail:
14868 return NULL;
14869 }
14870
14871
14872 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14873 PyObject *resultobj = 0;
14874 wxJoystick *arg1 = (wxJoystick *) 0 ;
14875 int result;
14876 void *argp1 = 0 ;
14877 int res1 = 0 ;
14878 PyObject *swig_obj[1] ;
14879
14880 if (!args) SWIG_fail;
14881 swig_obj[0] = args;
14882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14883 if (!SWIG_IsOK(res1)) {
14884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14885 }
14886 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14887 {
14888 PyThreadState* __tstate = wxPyBeginAllowThreads();
14889 result = (int)(arg1)->GetRudderMin();
14890 wxPyEndAllowThreads(__tstate);
14891 if (PyErr_Occurred()) SWIG_fail;
14892 }
14893 resultobj = SWIG_From_int(static_cast< int >(result));
14894 return resultobj;
14895 fail:
14896 return NULL;
14897 }
14898
14899
14900 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14901 PyObject *resultobj = 0;
14902 wxJoystick *arg1 = (wxJoystick *) 0 ;
14903 int result;
14904 void *argp1 = 0 ;
14905 int res1 = 0 ;
14906 PyObject *swig_obj[1] ;
14907
14908 if (!args) SWIG_fail;
14909 swig_obj[0] = args;
14910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14911 if (!SWIG_IsOK(res1)) {
14912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14913 }
14914 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (int)(arg1)->GetRudderMax();
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_From_int(static_cast< int >(result));
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14929 PyObject *resultobj = 0;
14930 wxJoystick *arg1 = (wxJoystick *) 0 ;
14931 int result;
14932 void *argp1 = 0 ;
14933 int res1 = 0 ;
14934 PyObject *swig_obj[1] ;
14935
14936 if (!args) SWIG_fail;
14937 swig_obj[0] = args;
14938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14939 if (!SWIG_IsOK(res1)) {
14940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14941 }
14942 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (int)(arg1)->GetUMin();
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 resultobj = SWIG_From_int(static_cast< int >(result));
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14957 PyObject *resultobj = 0;
14958 wxJoystick *arg1 = (wxJoystick *) 0 ;
14959 int result;
14960 void *argp1 = 0 ;
14961 int res1 = 0 ;
14962 PyObject *swig_obj[1] ;
14963
14964 if (!args) SWIG_fail;
14965 swig_obj[0] = args;
14966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14967 if (!SWIG_IsOK(res1)) {
14968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14969 }
14970 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14971 {
14972 PyThreadState* __tstate = wxPyBeginAllowThreads();
14973 result = (int)(arg1)->GetUMax();
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 resultobj = SWIG_From_int(static_cast< int >(result));
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14985 PyObject *resultobj = 0;
14986 wxJoystick *arg1 = (wxJoystick *) 0 ;
14987 int result;
14988 void *argp1 = 0 ;
14989 int res1 = 0 ;
14990 PyObject *swig_obj[1] ;
14991
14992 if (!args) SWIG_fail;
14993 swig_obj[0] = args;
14994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14995 if (!SWIG_IsOK(res1)) {
14996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14997 }
14998 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = (int)(arg1)->GetVMin();
15002 wxPyEndAllowThreads(__tstate);
15003 if (PyErr_Occurred()) SWIG_fail;
15004 }
15005 resultobj = SWIG_From_int(static_cast< int >(result));
15006 return resultobj;
15007 fail:
15008 return NULL;
15009 }
15010
15011
15012 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15013 PyObject *resultobj = 0;
15014 wxJoystick *arg1 = (wxJoystick *) 0 ;
15015 int result;
15016 void *argp1 = 0 ;
15017 int res1 = 0 ;
15018 PyObject *swig_obj[1] ;
15019
15020 if (!args) SWIG_fail;
15021 swig_obj[0] = args;
15022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15023 if (!SWIG_IsOK(res1)) {
15024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15025 }
15026 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (int)(arg1)->GetVMax();
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 resultobj = SWIG_From_int(static_cast< int >(result));
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15041 PyObject *resultobj = 0;
15042 wxJoystick *arg1 = (wxJoystick *) 0 ;
15043 bool result;
15044 void *argp1 = 0 ;
15045 int res1 = 0 ;
15046 PyObject *swig_obj[1] ;
15047
15048 if (!args) SWIG_fail;
15049 swig_obj[0] = args;
15050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15051 if (!SWIG_IsOK(res1)) {
15052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
15053 }
15054 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = (bool)(arg1)->HasRudder();
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 {
15062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15063 }
15064 return resultobj;
15065 fail:
15066 return NULL;
15067 }
15068
15069
15070 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15071 PyObject *resultobj = 0;
15072 wxJoystick *arg1 = (wxJoystick *) 0 ;
15073 bool result;
15074 void *argp1 = 0 ;
15075 int res1 = 0 ;
15076 PyObject *swig_obj[1] ;
15077
15078 if (!args) SWIG_fail;
15079 swig_obj[0] = args;
15080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15081 if (!SWIG_IsOK(res1)) {
15082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
15083 }
15084 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15085 {
15086 PyThreadState* __tstate = wxPyBeginAllowThreads();
15087 result = (bool)(arg1)->HasZ();
15088 wxPyEndAllowThreads(__tstate);
15089 if (PyErr_Occurred()) SWIG_fail;
15090 }
15091 {
15092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15093 }
15094 return resultobj;
15095 fail:
15096 return NULL;
15097 }
15098
15099
15100 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15101 PyObject *resultobj = 0;
15102 wxJoystick *arg1 = (wxJoystick *) 0 ;
15103 bool result;
15104 void *argp1 = 0 ;
15105 int res1 = 0 ;
15106 PyObject *swig_obj[1] ;
15107
15108 if (!args) SWIG_fail;
15109 swig_obj[0] = args;
15110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15111 if (!SWIG_IsOK(res1)) {
15112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
15113 }
15114 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15115 {
15116 PyThreadState* __tstate = wxPyBeginAllowThreads();
15117 result = (bool)(arg1)->HasU();
15118 wxPyEndAllowThreads(__tstate);
15119 if (PyErr_Occurred()) SWIG_fail;
15120 }
15121 {
15122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15123 }
15124 return resultobj;
15125 fail:
15126 return NULL;
15127 }
15128
15129
15130 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15131 PyObject *resultobj = 0;
15132 wxJoystick *arg1 = (wxJoystick *) 0 ;
15133 bool result;
15134 void *argp1 = 0 ;
15135 int res1 = 0 ;
15136 PyObject *swig_obj[1] ;
15137
15138 if (!args) SWIG_fail;
15139 swig_obj[0] = args;
15140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15141 if (!SWIG_IsOK(res1)) {
15142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15143 }
15144 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15145 {
15146 PyThreadState* __tstate = wxPyBeginAllowThreads();
15147 result = (bool)(arg1)->HasV();
15148 wxPyEndAllowThreads(__tstate);
15149 if (PyErr_Occurred()) SWIG_fail;
15150 }
15151 {
15152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15153 }
15154 return resultobj;
15155 fail:
15156 return NULL;
15157 }
15158
15159
15160 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15161 PyObject *resultobj = 0;
15162 wxJoystick *arg1 = (wxJoystick *) 0 ;
15163 bool result;
15164 void *argp1 = 0 ;
15165 int res1 = 0 ;
15166 PyObject *swig_obj[1] ;
15167
15168 if (!args) SWIG_fail;
15169 swig_obj[0] = args;
15170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15171 if (!SWIG_IsOK(res1)) {
15172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15173 }
15174 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15175 {
15176 PyThreadState* __tstate = wxPyBeginAllowThreads();
15177 result = (bool)(arg1)->HasPOV();
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 {
15182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15183 }
15184 return resultobj;
15185 fail:
15186 return NULL;
15187 }
15188
15189
15190 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15191 PyObject *resultobj = 0;
15192 wxJoystick *arg1 = (wxJoystick *) 0 ;
15193 bool result;
15194 void *argp1 = 0 ;
15195 int res1 = 0 ;
15196 PyObject *swig_obj[1] ;
15197
15198 if (!args) SWIG_fail;
15199 swig_obj[0] = args;
15200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15201 if (!SWIG_IsOK(res1)) {
15202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15203 }
15204 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 result = (bool)(arg1)->HasPOV4Dir();
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 {
15212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15213 }
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15221 PyObject *resultobj = 0;
15222 wxJoystick *arg1 = (wxJoystick *) 0 ;
15223 bool result;
15224 void *argp1 = 0 ;
15225 int res1 = 0 ;
15226 PyObject *swig_obj[1] ;
15227
15228 if (!args) SWIG_fail;
15229 swig_obj[0] = args;
15230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15231 if (!SWIG_IsOK(res1)) {
15232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15233 }
15234 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15235 {
15236 PyThreadState* __tstate = wxPyBeginAllowThreads();
15237 result = (bool)(arg1)->HasPOVCTS();
15238 wxPyEndAllowThreads(__tstate);
15239 if (PyErr_Occurred()) SWIG_fail;
15240 }
15241 {
15242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15243 }
15244 return resultobj;
15245 fail:
15246 return NULL;
15247 }
15248
15249
15250 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15251 PyObject *resultobj = 0;
15252 wxJoystick *arg1 = (wxJoystick *) 0 ;
15253 wxWindow *arg2 = (wxWindow *) 0 ;
15254 int arg3 = (int) 0 ;
15255 bool result;
15256 void *argp1 = 0 ;
15257 int res1 = 0 ;
15258 void *argp2 = 0 ;
15259 int res2 = 0 ;
15260 int val3 ;
15261 int ecode3 = 0 ;
15262 PyObject * obj0 = 0 ;
15263 PyObject * obj1 = 0 ;
15264 PyObject * obj2 = 0 ;
15265 char * kwnames[] = {
15266 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15267 };
15268
15269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15271 if (!SWIG_IsOK(res1)) {
15272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15273 }
15274 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15276 if (!SWIG_IsOK(res2)) {
15277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15278 }
15279 arg2 = reinterpret_cast< wxWindow * >(argp2);
15280 if (obj2) {
15281 ecode3 = SWIG_AsVal_int(obj2, &val3);
15282 if (!SWIG_IsOK(ecode3)) {
15283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15284 }
15285 arg3 = static_cast< int >(val3);
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (bool)(arg1)->SetCapture(arg2,arg3);
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 {
15294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15295 }
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15303 PyObject *resultobj = 0;
15304 wxJoystick *arg1 = (wxJoystick *) 0 ;
15305 bool result;
15306 void *argp1 = 0 ;
15307 int res1 = 0 ;
15308 PyObject *swig_obj[1] ;
15309
15310 if (!args) SWIG_fail;
15311 swig_obj[0] = args;
15312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15315 }
15316 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (bool)(arg1)->ReleaseCapture();
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 {
15324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15325 }
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15333 PyObject *obj;
15334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15335 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15336 return SWIG_Py_Void();
15337 }
15338
15339 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15340 return SWIG_Python_InitShadowInstance(args);
15341 }
15342
15343 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15344 PyObject *resultobj = 0;
15345 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15346 int arg2 = (int) 0 ;
15347 int arg3 = (int) wxJOYSTICK1 ;
15348 int arg4 = (int) 0 ;
15349 wxJoystickEvent *result = 0 ;
15350 int val1 ;
15351 int ecode1 = 0 ;
15352 int val2 ;
15353 int ecode2 = 0 ;
15354 int val3 ;
15355 int ecode3 = 0 ;
15356 int val4 ;
15357 int ecode4 = 0 ;
15358 PyObject * obj0 = 0 ;
15359 PyObject * obj1 = 0 ;
15360 PyObject * obj2 = 0 ;
15361 PyObject * obj3 = 0 ;
15362 char * kwnames[] = {
15363 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15364 };
15365
15366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15367 if (obj0) {
15368 ecode1 = SWIG_AsVal_int(obj0, &val1);
15369 if (!SWIG_IsOK(ecode1)) {
15370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15371 }
15372 arg1 = static_cast< wxEventType >(val1);
15373 }
15374 if (obj1) {
15375 ecode2 = SWIG_AsVal_int(obj1, &val2);
15376 if (!SWIG_IsOK(ecode2)) {
15377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15378 }
15379 arg2 = static_cast< int >(val2);
15380 }
15381 if (obj2) {
15382 ecode3 = SWIG_AsVal_int(obj2, &val3);
15383 if (!SWIG_IsOK(ecode3)) {
15384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15385 }
15386 arg3 = static_cast< int >(val3);
15387 }
15388 if (obj3) {
15389 ecode4 = SWIG_AsVal_int(obj3, &val4);
15390 if (!SWIG_IsOK(ecode4)) {
15391 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15392 }
15393 arg4 = static_cast< int >(val4);
15394 }
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15398 wxPyEndAllowThreads(__tstate);
15399 if (PyErr_Occurred()) SWIG_fail;
15400 }
15401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15402 return resultobj;
15403 fail:
15404 return NULL;
15405 }
15406
15407
15408 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15409 PyObject *resultobj = 0;
15410 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15411 wxPoint result;
15412 void *argp1 = 0 ;
15413 int res1 = 0 ;
15414 PyObject *swig_obj[1] ;
15415
15416 if (!args) SWIG_fail;
15417 swig_obj[0] = args;
15418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15419 if (!SWIG_IsOK(res1)) {
15420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15421 }
15422 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15423 {
15424 PyThreadState* __tstate = wxPyBeginAllowThreads();
15425 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15437 PyObject *resultobj = 0;
15438 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15439 int result;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 PyObject *swig_obj[1] ;
15443
15444 if (!args) SWIG_fail;
15445 swig_obj[0] = args;
15446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15447 if (!SWIG_IsOK(res1)) {
15448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15449 }
15450 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15454 wxPyEndAllowThreads(__tstate);
15455 if (PyErr_Occurred()) SWIG_fail;
15456 }
15457 resultobj = SWIG_From_int(static_cast< int >(result));
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15465 PyObject *resultobj = 0;
15466 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15467 int result;
15468 void *argp1 = 0 ;
15469 int res1 = 0 ;
15470 PyObject *swig_obj[1] ;
15471
15472 if (!args) SWIG_fail;
15473 swig_obj[0] = args;
15474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15475 if (!SWIG_IsOK(res1)) {
15476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15477 }
15478 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15479 {
15480 PyThreadState* __tstate = wxPyBeginAllowThreads();
15481 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15482 wxPyEndAllowThreads(__tstate);
15483 if (PyErr_Occurred()) SWIG_fail;
15484 }
15485 resultobj = SWIG_From_int(static_cast< int >(result));
15486 return resultobj;
15487 fail:
15488 return NULL;
15489 }
15490
15491
15492 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15493 PyObject *resultobj = 0;
15494 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15495 int result;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 PyObject *swig_obj[1] ;
15499
15500 if (!args) SWIG_fail;
15501 swig_obj[0] = args;
15502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15503 if (!SWIG_IsOK(res1)) {
15504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15505 }
15506 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15507 {
15508 PyThreadState* __tstate = wxPyBeginAllowThreads();
15509 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15510 wxPyEndAllowThreads(__tstate);
15511 if (PyErr_Occurred()) SWIG_fail;
15512 }
15513 resultobj = SWIG_From_int(static_cast< int >(result));
15514 return resultobj;
15515 fail:
15516 return NULL;
15517 }
15518
15519
15520 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15521 PyObject *resultobj = 0;
15522 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15523 int result;
15524 void *argp1 = 0 ;
15525 int res1 = 0 ;
15526 PyObject *swig_obj[1] ;
15527
15528 if (!args) SWIG_fail;
15529 swig_obj[0] = args;
15530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15531 if (!SWIG_IsOK(res1)) {
15532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15533 }
15534 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15535 {
15536 PyThreadState* __tstate = wxPyBeginAllowThreads();
15537 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15538 wxPyEndAllowThreads(__tstate);
15539 if (PyErr_Occurred()) SWIG_fail;
15540 }
15541 resultobj = SWIG_From_int(static_cast< int >(result));
15542 return resultobj;
15543 fail:
15544 return NULL;
15545 }
15546
15547
15548 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15549 PyObject *resultobj = 0;
15550 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15551 int arg2 ;
15552 void *argp1 = 0 ;
15553 int res1 = 0 ;
15554 int val2 ;
15555 int ecode2 = 0 ;
15556 PyObject * obj0 = 0 ;
15557 PyObject * obj1 = 0 ;
15558 char * kwnames[] = {
15559 (char *) "self",(char *) "stick", NULL
15560 };
15561
15562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15564 if (!SWIG_IsOK(res1)) {
15565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15566 }
15567 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15568 ecode2 = SWIG_AsVal_int(obj1, &val2);
15569 if (!SWIG_IsOK(ecode2)) {
15570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15571 }
15572 arg2 = static_cast< int >(val2);
15573 {
15574 PyThreadState* __tstate = wxPyBeginAllowThreads();
15575 (arg1)->SetJoystick(arg2);
15576 wxPyEndAllowThreads(__tstate);
15577 if (PyErr_Occurred()) SWIG_fail;
15578 }
15579 resultobj = SWIG_Py_Void();
15580 return resultobj;
15581 fail:
15582 return NULL;
15583 }
15584
15585
15586 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15587 PyObject *resultobj = 0;
15588 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15589 int arg2 ;
15590 void *argp1 = 0 ;
15591 int res1 = 0 ;
15592 int val2 ;
15593 int ecode2 = 0 ;
15594 PyObject * obj0 = 0 ;
15595 PyObject * obj1 = 0 ;
15596 char * kwnames[] = {
15597 (char *) "self",(char *) "state", NULL
15598 };
15599
15600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15602 if (!SWIG_IsOK(res1)) {
15603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15604 }
15605 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15606 ecode2 = SWIG_AsVal_int(obj1, &val2);
15607 if (!SWIG_IsOK(ecode2)) {
15608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15609 }
15610 arg2 = static_cast< int >(val2);
15611 {
15612 PyThreadState* __tstate = wxPyBeginAllowThreads();
15613 (arg1)->SetButtonState(arg2);
15614 wxPyEndAllowThreads(__tstate);
15615 if (PyErr_Occurred()) SWIG_fail;
15616 }
15617 resultobj = SWIG_Py_Void();
15618 return resultobj;
15619 fail:
15620 return NULL;
15621 }
15622
15623
15624 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15625 PyObject *resultobj = 0;
15626 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15627 int arg2 ;
15628 void *argp1 = 0 ;
15629 int res1 = 0 ;
15630 int val2 ;
15631 int ecode2 = 0 ;
15632 PyObject * obj0 = 0 ;
15633 PyObject * obj1 = 0 ;
15634 char * kwnames[] = {
15635 (char *) "self",(char *) "change", NULL
15636 };
15637
15638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15640 if (!SWIG_IsOK(res1)) {
15641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15642 }
15643 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15644 ecode2 = SWIG_AsVal_int(obj1, &val2);
15645 if (!SWIG_IsOK(ecode2)) {
15646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15647 }
15648 arg2 = static_cast< int >(val2);
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 (arg1)->SetButtonChange(arg2);
15652 wxPyEndAllowThreads(__tstate);
15653 if (PyErr_Occurred()) SWIG_fail;
15654 }
15655 resultobj = SWIG_Py_Void();
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15663 PyObject *resultobj = 0;
15664 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15665 wxPoint *arg2 = 0 ;
15666 void *argp1 = 0 ;
15667 int res1 = 0 ;
15668 wxPoint temp2 ;
15669 PyObject * obj0 = 0 ;
15670 PyObject * obj1 = 0 ;
15671 char * kwnames[] = {
15672 (char *) "self",(char *) "pos", NULL
15673 };
15674
15675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15677 if (!SWIG_IsOK(res1)) {
15678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15679 }
15680 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15681 {
15682 arg2 = &temp2;
15683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15684 }
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 (arg1)->SetPosition((wxPoint const &)*arg2);
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 resultobj = SWIG_Py_Void();
15692 return resultobj;
15693 fail:
15694 return NULL;
15695 }
15696
15697
15698 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15699 PyObject *resultobj = 0;
15700 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15701 int arg2 ;
15702 void *argp1 = 0 ;
15703 int res1 = 0 ;
15704 int val2 ;
15705 int ecode2 = 0 ;
15706 PyObject * obj0 = 0 ;
15707 PyObject * obj1 = 0 ;
15708 char * kwnames[] = {
15709 (char *) "self",(char *) "zPos", NULL
15710 };
15711
15712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15714 if (!SWIG_IsOK(res1)) {
15715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15716 }
15717 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15718 ecode2 = SWIG_AsVal_int(obj1, &val2);
15719 if (!SWIG_IsOK(ecode2)) {
15720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15721 }
15722 arg2 = static_cast< int >(val2);
15723 {
15724 PyThreadState* __tstate = wxPyBeginAllowThreads();
15725 (arg1)->SetZPosition(arg2);
15726 wxPyEndAllowThreads(__tstate);
15727 if (PyErr_Occurred()) SWIG_fail;
15728 }
15729 resultobj = SWIG_Py_Void();
15730 return resultobj;
15731 fail:
15732 return NULL;
15733 }
15734
15735
15736 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15737 PyObject *resultobj = 0;
15738 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15739 bool result;
15740 void *argp1 = 0 ;
15741 int res1 = 0 ;
15742 PyObject *swig_obj[1] ;
15743
15744 if (!args) SWIG_fail;
15745 swig_obj[0] = args;
15746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15747 if (!SWIG_IsOK(res1)) {
15748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15749 }
15750 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15754 wxPyEndAllowThreads(__tstate);
15755 if (PyErr_Occurred()) SWIG_fail;
15756 }
15757 {
15758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15759 }
15760 return resultobj;
15761 fail:
15762 return NULL;
15763 }
15764
15765
15766 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15767 PyObject *resultobj = 0;
15768 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15769 bool result;
15770 void *argp1 = 0 ;
15771 int res1 = 0 ;
15772 PyObject *swig_obj[1] ;
15773
15774 if (!args) SWIG_fail;
15775 swig_obj[0] = args;
15776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15777 if (!SWIG_IsOK(res1)) {
15778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15779 }
15780 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15781 {
15782 PyThreadState* __tstate = wxPyBeginAllowThreads();
15783 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15784 wxPyEndAllowThreads(__tstate);
15785 if (PyErr_Occurred()) SWIG_fail;
15786 }
15787 {
15788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15789 }
15790 return resultobj;
15791 fail:
15792 return NULL;
15793 }
15794
15795
15796 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15797 PyObject *resultobj = 0;
15798 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15799 bool result;
15800 void *argp1 = 0 ;
15801 int res1 = 0 ;
15802 PyObject *swig_obj[1] ;
15803
15804 if (!args) SWIG_fail;
15805 swig_obj[0] = args;
15806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15807 if (!SWIG_IsOK(res1)) {
15808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15809 }
15810 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15811 {
15812 PyThreadState* __tstate = wxPyBeginAllowThreads();
15813 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15814 wxPyEndAllowThreads(__tstate);
15815 if (PyErr_Occurred()) SWIG_fail;
15816 }
15817 {
15818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15819 }
15820 return resultobj;
15821 fail:
15822 return NULL;
15823 }
15824
15825
15826 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15827 PyObject *resultobj = 0;
15828 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15829 int arg2 = (int) wxJOY_BUTTON_ANY ;
15830 bool result;
15831 void *argp1 = 0 ;
15832 int res1 = 0 ;
15833 int val2 ;
15834 int ecode2 = 0 ;
15835 PyObject * obj0 = 0 ;
15836 PyObject * obj1 = 0 ;
15837 char * kwnames[] = {
15838 (char *) "self",(char *) "but", NULL
15839 };
15840
15841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15843 if (!SWIG_IsOK(res1)) {
15844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15845 }
15846 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15847 if (obj1) {
15848 ecode2 = SWIG_AsVal_int(obj1, &val2);
15849 if (!SWIG_IsOK(ecode2)) {
15850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15851 }
15852 arg2 = static_cast< int >(val2);
15853 }
15854 {
15855 PyThreadState* __tstate = wxPyBeginAllowThreads();
15856 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 {
15861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15862 }
15863 return resultobj;
15864 fail:
15865 return NULL;
15866 }
15867
15868
15869 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15870 PyObject *resultobj = 0;
15871 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15872 int arg2 = (int) wxJOY_BUTTON_ANY ;
15873 bool result;
15874 void *argp1 = 0 ;
15875 int res1 = 0 ;
15876 int val2 ;
15877 int ecode2 = 0 ;
15878 PyObject * obj0 = 0 ;
15879 PyObject * obj1 = 0 ;
15880 char * kwnames[] = {
15881 (char *) "self",(char *) "but", NULL
15882 };
15883
15884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15886 if (!SWIG_IsOK(res1)) {
15887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15888 }
15889 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15890 if (obj1) {
15891 ecode2 = SWIG_AsVal_int(obj1, &val2);
15892 if (!SWIG_IsOK(ecode2)) {
15893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15894 }
15895 arg2 = static_cast< int >(val2);
15896 }
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 {
15904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15905 }
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj = 0;
15914 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15915 int arg2 = (int) wxJOY_BUTTON_ANY ;
15916 bool result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 int val2 ;
15920 int ecode2 = 0 ;
15921 PyObject * obj0 = 0 ;
15922 PyObject * obj1 = 0 ;
15923 char * kwnames[] = {
15924 (char *) "self",(char *) "but", NULL
15925 };
15926
15927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15929 if (!SWIG_IsOK(res1)) {
15930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15931 }
15932 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15933 if (obj1) {
15934 ecode2 = SWIG_AsVal_int(obj1, &val2);
15935 if (!SWIG_IsOK(ecode2)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15937 }
15938 arg2 = static_cast< int >(val2);
15939 }
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 {
15947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15948 }
15949 return resultobj;
15950 fail:
15951 return NULL;
15952 }
15953
15954
15955 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15956 PyObject *obj;
15957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15958 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15959 return SWIG_Py_Void();
15960 }
15961
15962 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15963 return SWIG_Python_InitShadowInstance(args);
15964 }
15965
15966 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15967 PyObject *resultobj = 0;
15968 wxString const &arg1_defvalue = wxPyEmptyString ;
15969 wxString *arg1 = (wxString *) &arg1_defvalue ;
15970 wxSound *result = 0 ;
15971 bool temp1 = false ;
15972 PyObject * obj0 = 0 ;
15973 char * kwnames[] = {
15974 (char *) "fileName", NULL
15975 };
15976
15977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15978 if (obj0) {
15979 {
15980 arg1 = wxString_in_helper(obj0);
15981 if (arg1 == NULL) SWIG_fail;
15982 temp1 = true;
15983 }
15984 }
15985 {
15986 if (!wxPyCheckForApp()) SWIG_fail;
15987 PyThreadState* __tstate = wxPyBeginAllowThreads();
15988 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15993 {
15994 if (temp1)
15995 delete arg1;
15996 }
15997 return resultobj;
15998 fail:
15999 {
16000 if (temp1)
16001 delete arg1;
16002 }
16003 return NULL;
16004 }
16005
16006
16007 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16008 PyObject *resultobj = 0;
16009 PyObject *arg1 = (PyObject *) 0 ;
16010 wxSound *result = 0 ;
16011 PyObject * obj0 = 0 ;
16012 char * kwnames[] = {
16013 (char *) "data", NULL
16014 };
16015
16016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16017 arg1 = obj0;
16018 {
16019 if (!wxPyCheckForApp()) SWIG_fail;
16020 PyThreadState* __tstate = wxPyBeginAllowThreads();
16021 result = (wxSound *)new_wxSound(arg1);
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16026 return resultobj;
16027 fail:
16028 return NULL;
16029 }
16030
16031
16032 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16033 PyObject *resultobj = 0;
16034 wxSound *arg1 = (wxSound *) 0 ;
16035 void *argp1 = 0 ;
16036 int res1 = 0 ;
16037 PyObject *swig_obj[1] ;
16038
16039 if (!args) SWIG_fail;
16040 swig_obj[0] = args;
16041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16042 if (!SWIG_IsOK(res1)) {
16043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16044 }
16045 arg1 = reinterpret_cast< wxSound * >(argp1);
16046 {
16047 PyThreadState* __tstate = wxPyBeginAllowThreads();
16048 delete arg1;
16049
16050 wxPyEndAllowThreads(__tstate);
16051 if (PyErr_Occurred()) SWIG_fail;
16052 }
16053 resultobj = SWIG_Py_Void();
16054 return resultobj;
16055 fail:
16056 return NULL;
16057 }
16058
16059
16060 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16061 PyObject *resultobj = 0;
16062 wxSound *arg1 = (wxSound *) 0 ;
16063 wxString *arg2 = 0 ;
16064 bool result;
16065 void *argp1 = 0 ;
16066 int res1 = 0 ;
16067 bool temp2 = false ;
16068 PyObject * obj0 = 0 ;
16069 PyObject * obj1 = 0 ;
16070 char * kwnames[] = {
16071 (char *) "self",(char *) "fileName", NULL
16072 };
16073
16074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
16075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16076 if (!SWIG_IsOK(res1)) {
16077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
16078 }
16079 arg1 = reinterpret_cast< wxSound * >(argp1);
16080 {
16081 arg2 = wxString_in_helper(obj1);
16082 if (arg2 == NULL) SWIG_fail;
16083 temp2 = true;
16084 }
16085 {
16086 PyThreadState* __tstate = wxPyBeginAllowThreads();
16087 result = (bool)(arg1)->Create((wxString const &)*arg2);
16088 wxPyEndAllowThreads(__tstate);
16089 if (PyErr_Occurred()) SWIG_fail;
16090 }
16091 {
16092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16093 }
16094 {
16095 if (temp2)
16096 delete arg2;
16097 }
16098 return resultobj;
16099 fail:
16100 {
16101 if (temp2)
16102 delete arg2;
16103 }
16104 return NULL;
16105 }
16106
16107
16108 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj = 0;
16110 wxSound *arg1 = (wxSound *) 0 ;
16111 PyObject *arg2 = (PyObject *) 0 ;
16112 bool result;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 PyObject * obj0 = 0 ;
16116 PyObject * obj1 = 0 ;
16117 char * kwnames[] = {
16118 (char *) "self",(char *) "data", NULL
16119 };
16120
16121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16123 if (!SWIG_IsOK(res1)) {
16124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16125 }
16126 arg1 = reinterpret_cast< wxSound * >(argp1);
16127 arg2 = obj1;
16128 {
16129 PyThreadState* __tstate = wxPyBeginAllowThreads();
16130 result = (bool)wxSound_CreateFromData(arg1,arg2);
16131 wxPyEndAllowThreads(__tstate);
16132 if (PyErr_Occurred()) SWIG_fail;
16133 }
16134 {
16135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16136 }
16137 return resultobj;
16138 fail:
16139 return NULL;
16140 }
16141
16142
16143 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16144 PyObject *resultobj = 0;
16145 wxSound *arg1 = (wxSound *) 0 ;
16146 bool result;
16147 void *argp1 = 0 ;
16148 int res1 = 0 ;
16149 PyObject *swig_obj[1] ;
16150
16151 if (!args) SWIG_fail;
16152 swig_obj[0] = args;
16153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16154 if (!SWIG_IsOK(res1)) {
16155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16156 }
16157 arg1 = reinterpret_cast< wxSound * >(argp1);
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 result = (bool)(arg1)->IsOk();
16161 wxPyEndAllowThreads(__tstate);
16162 if (PyErr_Occurred()) SWIG_fail;
16163 }
16164 {
16165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16166 }
16167 return resultobj;
16168 fail:
16169 return NULL;
16170 }
16171
16172
16173 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16174 PyObject *resultobj = 0;
16175 wxSound *arg1 = (wxSound *) 0 ;
16176 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16177 bool result;
16178 void *argp1 = 0 ;
16179 int res1 = 0 ;
16180 unsigned int val2 ;
16181 int ecode2 = 0 ;
16182 PyObject * obj0 = 0 ;
16183 PyObject * obj1 = 0 ;
16184 char * kwnames[] = {
16185 (char *) "self",(char *) "flags", NULL
16186 };
16187
16188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16190 if (!SWIG_IsOK(res1)) {
16191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16192 }
16193 arg1 = reinterpret_cast< wxSound * >(argp1);
16194 if (obj1) {
16195 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16196 if (!SWIG_IsOK(ecode2)) {
16197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16198 }
16199 arg2 = static_cast< unsigned int >(val2);
16200 }
16201 {
16202 if (!wxPyCheckForApp()) SWIG_fail;
16203 PyThreadState* __tstate = wxPyBeginAllowThreads();
16204 result = (bool)((wxSound const *)arg1)->Play(arg2);
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 {
16209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16210 }
16211 return resultobj;
16212 fail:
16213 return NULL;
16214 }
16215
16216
16217 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16218 PyObject *resultobj = 0;
16219 wxString *arg1 = 0 ;
16220 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16221 bool result;
16222 bool temp1 = false ;
16223 unsigned int val2 ;
16224 int ecode2 = 0 ;
16225 PyObject * obj0 = 0 ;
16226 PyObject * obj1 = 0 ;
16227 char * kwnames[] = {
16228 (char *) "filename",(char *) "flags", NULL
16229 };
16230
16231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16232 {
16233 arg1 = wxString_in_helper(obj0);
16234 if (arg1 == NULL) SWIG_fail;
16235 temp1 = true;
16236 }
16237 if (obj1) {
16238 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16239 if (!SWIG_IsOK(ecode2)) {
16240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16241 }
16242 arg2 = static_cast< unsigned int >(val2);
16243 }
16244 {
16245 if (!wxPyCheckForApp()) SWIG_fail;
16246 PyThreadState* __tstate = wxPyBeginAllowThreads();
16247 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16248 wxPyEndAllowThreads(__tstate);
16249 if (PyErr_Occurred()) SWIG_fail;
16250 }
16251 {
16252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16253 }
16254 {
16255 if (temp1)
16256 delete arg1;
16257 }
16258 return resultobj;
16259 fail:
16260 {
16261 if (temp1)
16262 delete arg1;
16263 }
16264 return NULL;
16265 }
16266
16267
16268 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16269 PyObject *resultobj = 0;
16270
16271 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16272 {
16273 if (!wxPyCheckForApp()) SWIG_fail;
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 wxSound::Stop();
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 resultobj = SWIG_Py_Void();
16280 return resultobj;
16281 fail:
16282 return NULL;
16283 }
16284
16285
16286 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16287 PyObject *obj;
16288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16289 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16290 return SWIG_Py_Void();
16291 }
16292
16293 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16294 return SWIG_Python_InitShadowInstance(args);
16295 }
16296
16297 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16298 PyObject *resultobj = 0;
16299 wxString *arg1 = 0 ;
16300 wxString *arg2 = 0 ;
16301 wxString *arg3 = 0 ;
16302 wxString *arg4 = 0 ;
16303 wxFileTypeInfo *result = 0 ;
16304 bool temp1 = false ;
16305 bool temp2 = false ;
16306 bool temp3 = false ;
16307 bool temp4 = false ;
16308 PyObject * obj0 = 0 ;
16309 PyObject * obj1 = 0 ;
16310 PyObject * obj2 = 0 ;
16311 PyObject * obj3 = 0 ;
16312 char * kwnames[] = {
16313 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16314 };
16315
16316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16317 {
16318 arg1 = wxString_in_helper(obj0);
16319 if (arg1 == NULL) SWIG_fail;
16320 temp1 = true;
16321 }
16322 {
16323 arg2 = wxString_in_helper(obj1);
16324 if (arg2 == NULL) SWIG_fail;
16325 temp2 = true;
16326 }
16327 {
16328 arg3 = wxString_in_helper(obj2);
16329 if (arg3 == NULL) SWIG_fail;
16330 temp3 = true;
16331 }
16332 {
16333 arg4 = wxString_in_helper(obj3);
16334 if (arg4 == NULL) SWIG_fail;
16335 temp4 = true;
16336 }
16337 {
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16340 wxPyEndAllowThreads(__tstate);
16341 if (PyErr_Occurred()) SWIG_fail;
16342 }
16343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16344 {
16345 if (temp1)
16346 delete arg1;
16347 }
16348 {
16349 if (temp2)
16350 delete arg2;
16351 }
16352 {
16353 if (temp3)
16354 delete arg3;
16355 }
16356 {
16357 if (temp4)
16358 delete arg4;
16359 }
16360 return resultobj;
16361 fail:
16362 {
16363 if (temp1)
16364 delete arg1;
16365 }
16366 {
16367 if (temp2)
16368 delete arg2;
16369 }
16370 {
16371 if (temp3)
16372 delete arg3;
16373 }
16374 {
16375 if (temp4)
16376 delete arg4;
16377 }
16378 return NULL;
16379 }
16380
16381
16382 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16383 PyObject *resultobj = 0;
16384 wxArrayString *arg1 = 0 ;
16385 wxFileTypeInfo *result = 0 ;
16386 bool temp1 = false ;
16387 PyObject * obj0 = 0 ;
16388 char * kwnames[] = {
16389 (char *) "sArray", NULL
16390 };
16391
16392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16393 {
16394 if (! PySequence_Check(obj0)) {
16395 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16396 SWIG_fail;
16397 }
16398 arg1 = new wxArrayString;
16399 temp1 = true;
16400 int i, len=PySequence_Length(obj0);
16401 for (i=0; i<len; i++) {
16402 PyObject* item = PySequence_GetItem(obj0, i);
16403 wxString* s = wxString_in_helper(item);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 arg1->Add(*s);
16406 delete s;
16407 Py_DECREF(item);
16408 }
16409 }
16410 {
16411 PyThreadState* __tstate = wxPyBeginAllowThreads();
16412 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16417 {
16418 if (temp1) delete arg1;
16419 }
16420 return resultobj;
16421 fail:
16422 {
16423 if (temp1) delete arg1;
16424 }
16425 return NULL;
16426 }
16427
16428
16429 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16430 PyObject *resultobj = 0;
16431 wxFileTypeInfo *result = 0 ;
16432
16433 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16434 {
16435 PyThreadState* __tstate = wxPyBeginAllowThreads();
16436 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16448 PyObject *resultobj = 0;
16449 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16450 bool result;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 PyObject *swig_obj[1] ;
16454
16455 if (!args) SWIG_fail;
16456 swig_obj[0] = args;
16457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16458 if (!SWIG_IsOK(res1)) {
16459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16460 }
16461 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16462 {
16463 PyThreadState* __tstate = wxPyBeginAllowThreads();
16464 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16470 }
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj = 0;
16479 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16480 wxString *arg2 = 0 ;
16481 int arg3 = (int) 0 ;
16482 void *argp1 = 0 ;
16483 int res1 = 0 ;
16484 bool temp2 = false ;
16485 int val3 ;
16486 int ecode3 = 0 ;
16487 PyObject * obj0 = 0 ;
16488 PyObject * obj1 = 0 ;
16489 PyObject * obj2 = 0 ;
16490 char * kwnames[] = {
16491 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16492 };
16493
16494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16496 if (!SWIG_IsOK(res1)) {
16497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16498 }
16499 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16500 {
16501 arg2 = wxString_in_helper(obj1);
16502 if (arg2 == NULL) SWIG_fail;
16503 temp2 = true;
16504 }
16505 if (obj2) {
16506 ecode3 = SWIG_AsVal_int(obj2, &val3);
16507 if (!SWIG_IsOK(ecode3)) {
16508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16509 }
16510 arg3 = static_cast< int >(val3);
16511 }
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 resultobj = SWIG_Py_Void();
16519 {
16520 if (temp2)
16521 delete arg2;
16522 }
16523 return resultobj;
16524 fail:
16525 {
16526 if (temp2)
16527 delete arg2;
16528 }
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16536 wxString *arg2 = 0 ;
16537 void *argp1 = 0 ;
16538 int res1 = 0 ;
16539 bool temp2 = false ;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 char * kwnames[] = {
16543 (char *) "self",(char *) "shortDesc", NULL
16544 };
16545
16546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16548 if (!SWIG_IsOK(res1)) {
16549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16550 }
16551 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16552 {
16553 arg2 = wxString_in_helper(obj1);
16554 if (arg2 == NULL) SWIG_fail;
16555 temp2 = true;
16556 }
16557 {
16558 PyThreadState* __tstate = wxPyBeginAllowThreads();
16559 (arg1)->SetShortDesc((wxString const &)*arg2);
16560 wxPyEndAllowThreads(__tstate);
16561 if (PyErr_Occurred()) SWIG_fail;
16562 }
16563 resultobj = SWIG_Py_Void();
16564 {
16565 if (temp2)
16566 delete arg2;
16567 }
16568 return resultobj;
16569 fail:
16570 {
16571 if (temp2)
16572 delete arg2;
16573 }
16574 return NULL;
16575 }
16576
16577
16578 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16579 PyObject *resultobj = 0;
16580 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16581 wxString *result = 0 ;
16582 void *argp1 = 0 ;
16583 int res1 = 0 ;
16584 PyObject *swig_obj[1] ;
16585
16586 if (!args) SWIG_fail;
16587 swig_obj[0] = args;
16588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16589 if (!SWIG_IsOK(res1)) {
16590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16591 }
16592 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16593 {
16594 PyThreadState* __tstate = wxPyBeginAllowThreads();
16595 {
16596 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16597 result = (wxString *) &_result_ref;
16598 }
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 {
16603 #if wxUSE_UNICODE
16604 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16605 #else
16606 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16607 #endif
16608 }
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16616 PyObject *resultobj = 0;
16617 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16618 wxString *result = 0 ;
16619 void *argp1 = 0 ;
16620 int res1 = 0 ;
16621 PyObject *swig_obj[1] ;
16622
16623 if (!args) SWIG_fail;
16624 swig_obj[0] = args;
16625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16626 if (!SWIG_IsOK(res1)) {
16627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16628 }
16629 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16630 {
16631 PyThreadState* __tstate = wxPyBeginAllowThreads();
16632 {
16633 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16634 result = (wxString *) &_result_ref;
16635 }
16636 wxPyEndAllowThreads(__tstate);
16637 if (PyErr_Occurred()) SWIG_fail;
16638 }
16639 {
16640 #if wxUSE_UNICODE
16641 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16642 #else
16643 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16644 #endif
16645 }
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16653 PyObject *resultobj = 0;
16654 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16655 wxString *result = 0 ;
16656 void *argp1 = 0 ;
16657 int res1 = 0 ;
16658 PyObject *swig_obj[1] ;
16659
16660 if (!args) SWIG_fail;
16661 swig_obj[0] = args;
16662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16663 if (!SWIG_IsOK(res1)) {
16664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16665 }
16666 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16667 {
16668 PyThreadState* __tstate = wxPyBeginAllowThreads();
16669 {
16670 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16671 result = (wxString *) &_result_ref;
16672 }
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 {
16677 #if wxUSE_UNICODE
16678 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16679 #else
16680 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16681 #endif
16682 }
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16690 PyObject *resultobj = 0;
16691 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16692 wxString *result = 0 ;
16693 void *argp1 = 0 ;
16694 int res1 = 0 ;
16695 PyObject *swig_obj[1] ;
16696
16697 if (!args) SWIG_fail;
16698 swig_obj[0] = args;
16699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16700 if (!SWIG_IsOK(res1)) {
16701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16702 }
16703 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16704 {
16705 PyThreadState* __tstate = wxPyBeginAllowThreads();
16706 {
16707 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16708 result = (wxString *) &_result_ref;
16709 }
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 {
16714 #if wxUSE_UNICODE
16715 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16716 #else
16717 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16718 #endif
16719 }
16720 return resultobj;
16721 fail:
16722 return NULL;
16723 }
16724
16725
16726 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16727 PyObject *resultobj = 0;
16728 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16729 wxString *result = 0 ;
16730 void *argp1 = 0 ;
16731 int res1 = 0 ;
16732 PyObject *swig_obj[1] ;
16733
16734 if (!args) SWIG_fail;
16735 swig_obj[0] = args;
16736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16737 if (!SWIG_IsOK(res1)) {
16738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16739 }
16740 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16741 {
16742 PyThreadState* __tstate = wxPyBeginAllowThreads();
16743 {
16744 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16745 result = (wxString *) &_result_ref;
16746 }
16747 wxPyEndAllowThreads(__tstate);
16748 if (PyErr_Occurred()) SWIG_fail;
16749 }
16750 {
16751 #if wxUSE_UNICODE
16752 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16753 #else
16754 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16755 #endif
16756 }
16757 return resultobj;
16758 fail:
16759 return NULL;
16760 }
16761
16762
16763 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16764 PyObject *resultobj = 0;
16765 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16766 wxArrayString *result = 0 ;
16767 void *argp1 = 0 ;
16768 int res1 = 0 ;
16769 PyObject *swig_obj[1] ;
16770
16771 if (!args) SWIG_fail;
16772 swig_obj[0] = args;
16773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16774 if (!SWIG_IsOK(res1)) {
16775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16776 }
16777 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16778 {
16779 PyThreadState* __tstate = wxPyBeginAllowThreads();
16780 {
16781 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16782 result = (wxArrayString *) &_result_ref;
16783 }
16784 wxPyEndAllowThreads(__tstate);
16785 if (PyErr_Occurred()) SWIG_fail;
16786 }
16787 {
16788 resultobj = wxArrayString2PyList_helper(*result);
16789 }
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16797 PyObject *resultobj = 0;
16798 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16799 size_t result;
16800 void *argp1 = 0 ;
16801 int res1 = 0 ;
16802 PyObject *swig_obj[1] ;
16803
16804 if (!args) SWIG_fail;
16805 swig_obj[0] = args;
16806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16807 if (!SWIG_IsOK(res1)) {
16808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16809 }
16810 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16818 return resultobj;
16819 fail:
16820 return NULL;
16821 }
16822
16823
16824 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16825 PyObject *resultobj = 0;
16826 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16827 wxString *result = 0 ;
16828 void *argp1 = 0 ;
16829 int res1 = 0 ;
16830 PyObject *swig_obj[1] ;
16831
16832 if (!args) SWIG_fail;
16833 swig_obj[0] = args;
16834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16835 if (!SWIG_IsOK(res1)) {
16836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16837 }
16838 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 {
16842 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16843 result = (wxString *) &_result_ref;
16844 }
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 {
16849 #if wxUSE_UNICODE
16850 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16851 #else
16852 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16853 #endif
16854 }
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16862 PyObject *resultobj = 0;
16863 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16864 int result;
16865 void *argp1 = 0 ;
16866 int res1 = 0 ;
16867 PyObject *swig_obj[1] ;
16868
16869 if (!args) SWIG_fail;
16870 swig_obj[0] = args;
16871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16874 }
16875 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16879 wxPyEndAllowThreads(__tstate);
16880 if (PyErr_Occurred()) SWIG_fail;
16881 }
16882 resultobj = SWIG_From_int(static_cast< int >(result));
16883 return resultobj;
16884 fail:
16885 return NULL;
16886 }
16887
16888
16889 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16890 PyObject *obj;
16891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16892 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16893 return SWIG_Py_Void();
16894 }
16895
16896 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16897 return SWIG_Python_InitShadowInstance(args);
16898 }
16899
16900 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16901 PyObject *resultobj = 0;
16902 wxFileTypeInfo *arg1 = 0 ;
16903 wxFileType *result = 0 ;
16904 void *argp1 = 0 ;
16905 int res1 = 0 ;
16906 PyObject * obj0 = 0 ;
16907 char * kwnames[] = {
16908 (char *) "ftInfo", NULL
16909 };
16910
16911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16912 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16913 if (!SWIG_IsOK(res1)) {
16914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16915 }
16916 if (!argp1) {
16917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16918 }
16919 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16927 return resultobj;
16928 fail:
16929 return NULL;
16930 }
16931
16932
16933 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16934 PyObject *resultobj = 0;
16935 wxFileType *arg1 = (wxFileType *) 0 ;
16936 void *argp1 = 0 ;
16937 int res1 = 0 ;
16938 PyObject *swig_obj[1] ;
16939
16940 if (!args) SWIG_fail;
16941 swig_obj[0] = args;
16942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16943 if (!SWIG_IsOK(res1)) {
16944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16945 }
16946 arg1 = reinterpret_cast< wxFileType * >(argp1);
16947 {
16948 PyThreadState* __tstate = wxPyBeginAllowThreads();
16949 delete arg1;
16950
16951 wxPyEndAllowThreads(__tstate);
16952 if (PyErr_Occurred()) SWIG_fail;
16953 }
16954 resultobj = SWIG_Py_Void();
16955 return resultobj;
16956 fail:
16957 return NULL;
16958 }
16959
16960
16961 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16962 PyObject *resultobj = 0;
16963 wxFileType *arg1 = (wxFileType *) 0 ;
16964 PyObject *result = 0 ;
16965 void *argp1 = 0 ;
16966 int res1 = 0 ;
16967 PyObject *swig_obj[1] ;
16968
16969 if (!args) SWIG_fail;
16970 swig_obj[0] = args;
16971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16972 if (!SWIG_IsOK(res1)) {
16973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16974 }
16975 arg1 = reinterpret_cast< wxFileType * >(argp1);
16976 {
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = (PyObject *)wxFileType_GetMimeType(arg1);
16979 wxPyEndAllowThreads(__tstate);
16980 if (PyErr_Occurred()) SWIG_fail;
16981 }
16982 resultobj = result;
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16990 PyObject *resultobj = 0;
16991 wxFileType *arg1 = (wxFileType *) 0 ;
16992 PyObject *result = 0 ;
16993 void *argp1 = 0 ;
16994 int res1 = 0 ;
16995 PyObject *swig_obj[1] ;
16996
16997 if (!args) SWIG_fail;
16998 swig_obj[0] = args;
16999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17000 if (!SWIG_IsOK(res1)) {
17001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17002 }
17003 arg1 = reinterpret_cast< wxFileType * >(argp1);
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 resultobj = result;
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17018 PyObject *resultobj = 0;
17019 wxFileType *arg1 = (wxFileType *) 0 ;
17020 PyObject *result = 0 ;
17021 void *argp1 = 0 ;
17022 int res1 = 0 ;
17023 PyObject *swig_obj[1] ;
17024
17025 if (!args) SWIG_fail;
17026 swig_obj[0] = args;
17027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17028 if (!SWIG_IsOK(res1)) {
17029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17030 }
17031 arg1 = reinterpret_cast< wxFileType * >(argp1);
17032 {
17033 PyThreadState* __tstate = wxPyBeginAllowThreads();
17034 result = (PyObject *)wxFileType_GetExtensions(arg1);
17035 wxPyEndAllowThreads(__tstate);
17036 if (PyErr_Occurred()) SWIG_fail;
17037 }
17038 resultobj = result;
17039 return resultobj;
17040 fail:
17041 return NULL;
17042 }
17043
17044
17045 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17046 PyObject *resultobj = 0;
17047 wxFileType *arg1 = (wxFileType *) 0 ;
17048 wxIcon *result = 0 ;
17049 void *argp1 = 0 ;
17050 int res1 = 0 ;
17051 PyObject *swig_obj[1] ;
17052
17053 if (!args) SWIG_fail;
17054 swig_obj[0] = args;
17055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17056 if (!SWIG_IsOK(res1)) {
17057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17058 }
17059 arg1 = reinterpret_cast< wxFileType * >(argp1);
17060 {
17061 PyThreadState* __tstate = wxPyBeginAllowThreads();
17062 result = (wxIcon *)wxFileType_GetIcon(arg1);
17063 wxPyEndAllowThreads(__tstate);
17064 if (PyErr_Occurred()) SWIG_fail;
17065 }
17066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
17067 return resultobj;
17068 fail:
17069 return NULL;
17070 }
17071
17072
17073 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17074 PyObject *resultobj = 0;
17075 wxFileType *arg1 = (wxFileType *) 0 ;
17076 PyObject *result = 0 ;
17077 void *argp1 = 0 ;
17078 int res1 = 0 ;
17079 PyObject *swig_obj[1] ;
17080
17081 if (!args) SWIG_fail;
17082 swig_obj[0] = args;
17083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17084 if (!SWIG_IsOK(res1)) {
17085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
17086 }
17087 arg1 = reinterpret_cast< wxFileType * >(argp1);
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 result = (PyObject *)wxFileType_GetIconInfo(arg1);
17091 wxPyEndAllowThreads(__tstate);
17092 if (PyErr_Occurred()) SWIG_fail;
17093 }
17094 resultobj = result;
17095 return resultobj;
17096 fail:
17097 return NULL;
17098 }
17099
17100
17101 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17102 PyObject *resultobj = 0;
17103 wxFileType *arg1 = (wxFileType *) 0 ;
17104 PyObject *result = 0 ;
17105 void *argp1 = 0 ;
17106 int res1 = 0 ;
17107 PyObject *swig_obj[1] ;
17108
17109 if (!args) SWIG_fail;
17110 swig_obj[0] = args;
17111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17112 if (!SWIG_IsOK(res1)) {
17113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17114 }
17115 arg1 = reinterpret_cast< wxFileType * >(argp1);
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 result = (PyObject *)wxFileType_GetDescription(arg1);
17119 wxPyEndAllowThreads(__tstate);
17120 if (PyErr_Occurred()) SWIG_fail;
17121 }
17122 resultobj = result;
17123 return resultobj;
17124 fail:
17125 return NULL;
17126 }
17127
17128
17129 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj = 0;
17131 wxFileType *arg1 = (wxFileType *) 0 ;
17132 wxString *arg2 = 0 ;
17133 wxString const &arg3_defvalue = wxPyEmptyString ;
17134 wxString *arg3 = (wxString *) &arg3_defvalue ;
17135 PyObject *result = 0 ;
17136 void *argp1 = 0 ;
17137 int res1 = 0 ;
17138 bool temp2 = false ;
17139 bool temp3 = false ;
17140 PyObject * obj0 = 0 ;
17141 PyObject * obj1 = 0 ;
17142 PyObject * obj2 = 0 ;
17143 char * kwnames[] = {
17144 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17145 };
17146
17147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17149 if (!SWIG_IsOK(res1)) {
17150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17151 }
17152 arg1 = reinterpret_cast< wxFileType * >(argp1);
17153 {
17154 arg2 = wxString_in_helper(obj1);
17155 if (arg2 == NULL) SWIG_fail;
17156 temp2 = true;
17157 }
17158 if (obj2) {
17159 {
17160 arg3 = wxString_in_helper(obj2);
17161 if (arg3 == NULL) SWIG_fail;
17162 temp3 = true;
17163 }
17164 }
17165 {
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17168 wxPyEndAllowThreads(__tstate);
17169 if (PyErr_Occurred()) SWIG_fail;
17170 }
17171 resultobj = result;
17172 {
17173 if (temp2)
17174 delete arg2;
17175 }
17176 {
17177 if (temp3)
17178 delete arg3;
17179 }
17180 return resultobj;
17181 fail:
17182 {
17183 if (temp2)
17184 delete arg2;
17185 }
17186 {
17187 if (temp3)
17188 delete arg3;
17189 }
17190 return NULL;
17191 }
17192
17193
17194 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj = 0;
17196 wxFileType *arg1 = (wxFileType *) 0 ;
17197 wxString *arg2 = 0 ;
17198 wxString const &arg3_defvalue = wxPyEmptyString ;
17199 wxString *arg3 = (wxString *) &arg3_defvalue ;
17200 PyObject *result = 0 ;
17201 void *argp1 = 0 ;
17202 int res1 = 0 ;
17203 bool temp2 = false ;
17204 bool temp3 = false ;
17205 PyObject * obj0 = 0 ;
17206 PyObject * obj1 = 0 ;
17207 PyObject * obj2 = 0 ;
17208 char * kwnames[] = {
17209 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17210 };
17211
17212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17214 if (!SWIG_IsOK(res1)) {
17215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17216 }
17217 arg1 = reinterpret_cast< wxFileType * >(argp1);
17218 {
17219 arg2 = wxString_in_helper(obj1);
17220 if (arg2 == NULL) SWIG_fail;
17221 temp2 = true;
17222 }
17223 if (obj2) {
17224 {
17225 arg3 = wxString_in_helper(obj2);
17226 if (arg3 == NULL) SWIG_fail;
17227 temp3 = true;
17228 }
17229 }
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17233 wxPyEndAllowThreads(__tstate);
17234 if (PyErr_Occurred()) SWIG_fail;
17235 }
17236 resultobj = result;
17237 {
17238 if (temp2)
17239 delete arg2;
17240 }
17241 {
17242 if (temp3)
17243 delete arg3;
17244 }
17245 return resultobj;
17246 fail:
17247 {
17248 if (temp2)
17249 delete arg2;
17250 }
17251 {
17252 if (temp3)
17253 delete arg3;
17254 }
17255 return NULL;
17256 }
17257
17258
17259 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj = 0;
17261 wxFileType *arg1 = (wxFileType *) 0 ;
17262 wxString *arg2 = 0 ;
17263 wxString const &arg3_defvalue = wxPyEmptyString ;
17264 wxString *arg3 = (wxString *) &arg3_defvalue ;
17265 PyObject *result = 0 ;
17266 void *argp1 = 0 ;
17267 int res1 = 0 ;
17268 bool temp2 = false ;
17269 bool temp3 = false ;
17270 PyObject * obj0 = 0 ;
17271 PyObject * obj1 = 0 ;
17272 PyObject * obj2 = 0 ;
17273 char * kwnames[] = {
17274 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17275 };
17276
17277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17279 if (!SWIG_IsOK(res1)) {
17280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17281 }
17282 arg1 = reinterpret_cast< wxFileType * >(argp1);
17283 {
17284 arg2 = wxString_in_helper(obj1);
17285 if (arg2 == NULL) SWIG_fail;
17286 temp2 = true;
17287 }
17288 if (obj2) {
17289 {
17290 arg3 = wxString_in_helper(obj2);
17291 if (arg3 == NULL) SWIG_fail;
17292 temp3 = true;
17293 }
17294 }
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 resultobj = result;
17302 {
17303 if (temp2)
17304 delete arg2;
17305 }
17306 {
17307 if (temp3)
17308 delete arg3;
17309 }
17310 return resultobj;
17311 fail:
17312 {
17313 if (temp2)
17314 delete arg2;
17315 }
17316 {
17317 if (temp3)
17318 delete arg3;
17319 }
17320 return NULL;
17321 }
17322
17323
17324 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17325 PyObject *resultobj = 0;
17326 wxFileType *arg1 = (wxFileType *) 0 ;
17327 wxString *arg2 = 0 ;
17328 wxString *arg3 = 0 ;
17329 bool arg4 = (bool) true ;
17330 bool result;
17331 void *argp1 = 0 ;
17332 int res1 = 0 ;
17333 bool temp2 = false ;
17334 bool temp3 = false ;
17335 bool val4 ;
17336 int ecode4 = 0 ;
17337 PyObject * obj0 = 0 ;
17338 PyObject * obj1 = 0 ;
17339 PyObject * obj2 = 0 ;
17340 PyObject * obj3 = 0 ;
17341 char * kwnames[] = {
17342 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17343 };
17344
17345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17347 if (!SWIG_IsOK(res1)) {
17348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17349 }
17350 arg1 = reinterpret_cast< wxFileType * >(argp1);
17351 {
17352 arg2 = wxString_in_helper(obj1);
17353 if (arg2 == NULL) SWIG_fail;
17354 temp2 = true;
17355 }
17356 {
17357 arg3 = wxString_in_helper(obj2);
17358 if (arg3 == NULL) SWIG_fail;
17359 temp3 = true;
17360 }
17361 if (obj3) {
17362 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17363 if (!SWIG_IsOK(ecode4)) {
17364 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17365 }
17366 arg4 = static_cast< bool >(val4);
17367 }
17368 {
17369 PyThreadState* __tstate = wxPyBeginAllowThreads();
17370 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17371 wxPyEndAllowThreads(__tstate);
17372 if (PyErr_Occurred()) SWIG_fail;
17373 }
17374 {
17375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17376 }
17377 {
17378 if (temp2)
17379 delete arg2;
17380 }
17381 {
17382 if (temp3)
17383 delete arg3;
17384 }
17385 return resultobj;
17386 fail:
17387 {
17388 if (temp2)
17389 delete arg2;
17390 }
17391 {
17392 if (temp3)
17393 delete arg3;
17394 }
17395 return NULL;
17396 }
17397
17398
17399 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17400 PyObject *resultobj = 0;
17401 wxFileType *arg1 = (wxFileType *) 0 ;
17402 wxString const &arg2_defvalue = wxPyEmptyString ;
17403 wxString *arg2 = (wxString *) &arg2_defvalue ;
17404 int arg3 = (int) 0 ;
17405 bool result;
17406 void *argp1 = 0 ;
17407 int res1 = 0 ;
17408 bool temp2 = false ;
17409 int val3 ;
17410 int ecode3 = 0 ;
17411 PyObject * obj0 = 0 ;
17412 PyObject * obj1 = 0 ;
17413 PyObject * obj2 = 0 ;
17414 char * kwnames[] = {
17415 (char *) "self",(char *) "cmd",(char *) "index", NULL
17416 };
17417
17418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17420 if (!SWIG_IsOK(res1)) {
17421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17422 }
17423 arg1 = reinterpret_cast< wxFileType * >(argp1);
17424 if (obj1) {
17425 {
17426 arg2 = wxString_in_helper(obj1);
17427 if (arg2 == NULL) SWIG_fail;
17428 temp2 = true;
17429 }
17430 }
17431 if (obj2) {
17432 ecode3 = SWIG_AsVal_int(obj2, &val3);
17433 if (!SWIG_IsOK(ecode3)) {
17434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17435 }
17436 arg3 = static_cast< int >(val3);
17437 }
17438 {
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 {
17445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17446 }
17447 {
17448 if (temp2)
17449 delete arg2;
17450 }
17451 return resultobj;
17452 fail:
17453 {
17454 if (temp2)
17455 delete arg2;
17456 }
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 PyObject *resultobj = 0;
17463 wxFileType *arg1 = (wxFileType *) 0 ;
17464 bool result;
17465 void *argp1 = 0 ;
17466 int res1 = 0 ;
17467 PyObject *swig_obj[1] ;
17468
17469 if (!args) SWIG_fail;
17470 swig_obj[0] = args;
17471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17472 if (!SWIG_IsOK(res1)) {
17473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17474 }
17475 arg1 = reinterpret_cast< wxFileType * >(argp1);
17476 {
17477 PyThreadState* __tstate = wxPyBeginAllowThreads();
17478 result = (bool)(arg1)->Unassociate();
17479 wxPyEndAllowThreads(__tstate);
17480 if (PyErr_Occurred()) SWIG_fail;
17481 }
17482 {
17483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17484 }
17485 return resultobj;
17486 fail:
17487 return NULL;
17488 }
17489
17490
17491 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17492 PyObject *resultobj = 0;
17493 wxString *arg1 = 0 ;
17494 wxString *arg2 = 0 ;
17495 wxString const &arg3_defvalue = wxPyEmptyString ;
17496 wxString *arg3 = (wxString *) &arg3_defvalue ;
17497 wxString result;
17498 bool temp1 = false ;
17499 bool temp2 = false ;
17500 bool temp3 = false ;
17501 PyObject * obj0 = 0 ;
17502 PyObject * obj1 = 0 ;
17503 PyObject * obj2 = 0 ;
17504 char * kwnames[] = {
17505 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17506 };
17507
17508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17509 {
17510 arg1 = wxString_in_helper(obj0);
17511 if (arg1 == NULL) SWIG_fail;
17512 temp1 = true;
17513 }
17514 {
17515 arg2 = wxString_in_helper(obj1);
17516 if (arg2 == NULL) SWIG_fail;
17517 temp2 = true;
17518 }
17519 if (obj2) {
17520 {
17521 arg3 = wxString_in_helper(obj2);
17522 if (arg3 == NULL) SWIG_fail;
17523 temp3 = true;
17524 }
17525 }
17526 {
17527 PyThreadState* __tstate = wxPyBeginAllowThreads();
17528 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 {
17533 #if wxUSE_UNICODE
17534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17535 #else
17536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17537 #endif
17538 }
17539 {
17540 if (temp1)
17541 delete arg1;
17542 }
17543 {
17544 if (temp2)
17545 delete arg2;
17546 }
17547 {
17548 if (temp3)
17549 delete arg3;
17550 }
17551 return resultobj;
17552 fail:
17553 {
17554 if (temp1)
17555 delete arg1;
17556 }
17557 {
17558 if (temp2)
17559 delete arg2;
17560 }
17561 {
17562 if (temp3)
17563 delete arg3;
17564 }
17565 return NULL;
17566 }
17567
17568
17569 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17570 PyObject *obj;
17571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17572 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17573 return SWIG_Py_Void();
17574 }
17575
17576 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17577 return SWIG_Python_InitShadowInstance(args);
17578 }
17579
17580 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17581 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17582 return 1;
17583 }
17584
17585
17586 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17587 PyObject *pyobj = 0;
17588
17589 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17590 return pyobj;
17591 }
17592
17593
17594 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17595 PyObject *resultobj = 0;
17596 wxString *arg1 = 0 ;
17597 wxString *arg2 = 0 ;
17598 bool result;
17599 bool temp1 = false ;
17600 bool temp2 = false ;
17601 PyObject * obj0 = 0 ;
17602 PyObject * obj1 = 0 ;
17603 char * kwnames[] = {
17604 (char *) "mimeType",(char *) "wildcard", NULL
17605 };
17606
17607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17608 {
17609 arg1 = wxString_in_helper(obj0);
17610 if (arg1 == NULL) SWIG_fail;
17611 temp1 = true;
17612 }
17613 {
17614 arg2 = wxString_in_helper(obj1);
17615 if (arg2 == NULL) SWIG_fail;
17616 temp2 = true;
17617 }
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17621 wxPyEndAllowThreads(__tstate);
17622 if (PyErr_Occurred()) SWIG_fail;
17623 }
17624 {
17625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17626 }
17627 {
17628 if (temp1)
17629 delete arg1;
17630 }
17631 {
17632 if (temp2)
17633 delete arg2;
17634 }
17635 return resultobj;
17636 fail:
17637 {
17638 if (temp1)
17639 delete arg1;
17640 }
17641 {
17642 if (temp2)
17643 delete arg2;
17644 }
17645 return NULL;
17646 }
17647
17648
17649 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17650 PyObject *resultobj = 0;
17651 wxMimeTypesManager *result = 0 ;
17652
17653 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17654 {
17655 PyThreadState* __tstate = wxPyBeginAllowThreads();
17656 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17657 wxPyEndAllowThreads(__tstate);
17658 if (PyErr_Occurred()) SWIG_fail;
17659 }
17660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj = 0;
17669 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17670 int arg2 = (int) wxMAILCAP_ALL ;
17671 wxString const &arg3_defvalue = wxPyEmptyString ;
17672 wxString *arg3 = (wxString *) &arg3_defvalue ;
17673 void *argp1 = 0 ;
17674 int res1 = 0 ;
17675 int val2 ;
17676 int ecode2 = 0 ;
17677 bool temp3 = false ;
17678 PyObject * obj0 = 0 ;
17679 PyObject * obj1 = 0 ;
17680 PyObject * obj2 = 0 ;
17681 char * kwnames[] = {
17682 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17683 };
17684
17685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17687 if (!SWIG_IsOK(res1)) {
17688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17689 }
17690 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17691 if (obj1) {
17692 ecode2 = SWIG_AsVal_int(obj1, &val2);
17693 if (!SWIG_IsOK(ecode2)) {
17694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17695 }
17696 arg2 = static_cast< int >(val2);
17697 }
17698 if (obj2) {
17699 {
17700 arg3 = wxString_in_helper(obj2);
17701 if (arg3 == NULL) SWIG_fail;
17702 temp3 = true;
17703 }
17704 }
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17708 wxPyEndAllowThreads(__tstate);
17709 if (PyErr_Occurred()) SWIG_fail;
17710 }
17711 resultobj = SWIG_Py_Void();
17712 {
17713 if (temp3)
17714 delete arg3;
17715 }
17716 return resultobj;
17717 fail:
17718 {
17719 if (temp3)
17720 delete arg3;
17721 }
17722 return NULL;
17723 }
17724
17725
17726 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17727 PyObject *resultobj = 0;
17728 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17729 void *argp1 = 0 ;
17730 int res1 = 0 ;
17731 PyObject *swig_obj[1] ;
17732
17733 if (!args) SWIG_fail;
17734 swig_obj[0] = args;
17735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17736 if (!SWIG_IsOK(res1)) {
17737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17738 }
17739 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17740 {
17741 PyThreadState* __tstate = wxPyBeginAllowThreads();
17742 (arg1)->ClearData();
17743 wxPyEndAllowThreads(__tstate);
17744 if (PyErr_Occurred()) SWIG_fail;
17745 }
17746 resultobj = SWIG_Py_Void();
17747 return resultobj;
17748 fail:
17749 return NULL;
17750 }
17751
17752
17753 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17754 PyObject *resultobj = 0;
17755 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17756 wxString *arg2 = 0 ;
17757 wxFileType *result = 0 ;
17758 void *argp1 = 0 ;
17759 int res1 = 0 ;
17760 bool temp2 = false ;
17761 PyObject * obj0 = 0 ;
17762 PyObject * obj1 = 0 ;
17763 char * kwnames[] = {
17764 (char *) "self",(char *) "ext", NULL
17765 };
17766
17767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17769 if (!SWIG_IsOK(res1)) {
17770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17771 }
17772 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17773 {
17774 arg2 = wxString_in_helper(obj1);
17775 if (arg2 == NULL) SWIG_fail;
17776 temp2 = true;
17777 }
17778 {
17779 PyThreadState* __tstate = wxPyBeginAllowThreads();
17780 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17785 {
17786 if (temp2)
17787 delete arg2;
17788 }
17789 return resultobj;
17790 fail:
17791 {
17792 if (temp2)
17793 delete arg2;
17794 }
17795 return NULL;
17796 }
17797
17798
17799 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj = 0;
17801 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17802 wxString *arg2 = 0 ;
17803 wxFileType *result = 0 ;
17804 void *argp1 = 0 ;
17805 int res1 = 0 ;
17806 bool temp2 = false ;
17807 PyObject * obj0 = 0 ;
17808 PyObject * obj1 = 0 ;
17809 char * kwnames[] = {
17810 (char *) "self",(char *) "mimeType", NULL
17811 };
17812
17813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17815 if (!SWIG_IsOK(res1)) {
17816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17817 }
17818 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17819 {
17820 arg2 = wxString_in_helper(obj1);
17821 if (arg2 == NULL) SWIG_fail;
17822 temp2 = true;
17823 }
17824 {
17825 PyThreadState* __tstate = wxPyBeginAllowThreads();
17826 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17827 wxPyEndAllowThreads(__tstate);
17828 if (PyErr_Occurred()) SWIG_fail;
17829 }
17830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17831 {
17832 if (temp2)
17833 delete arg2;
17834 }
17835 return resultobj;
17836 fail:
17837 {
17838 if (temp2)
17839 delete arg2;
17840 }
17841 return NULL;
17842 }
17843
17844
17845 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17846 PyObject *resultobj = 0;
17847 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17848 wxString *arg2 = 0 ;
17849 bool arg3 = (bool) false ;
17850 bool result;
17851 void *argp1 = 0 ;
17852 int res1 = 0 ;
17853 bool temp2 = false ;
17854 bool val3 ;
17855 int ecode3 = 0 ;
17856 PyObject * obj0 = 0 ;
17857 PyObject * obj1 = 0 ;
17858 PyObject * obj2 = 0 ;
17859 char * kwnames[] = {
17860 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17861 };
17862
17863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17865 if (!SWIG_IsOK(res1)) {
17866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17867 }
17868 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17869 {
17870 arg2 = wxString_in_helper(obj1);
17871 if (arg2 == NULL) SWIG_fail;
17872 temp2 = true;
17873 }
17874 if (obj2) {
17875 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17876 if (!SWIG_IsOK(ecode3)) {
17877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17878 }
17879 arg3 = static_cast< bool >(val3);
17880 }
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17884 wxPyEndAllowThreads(__tstate);
17885 if (PyErr_Occurred()) SWIG_fail;
17886 }
17887 {
17888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17889 }
17890 {
17891 if (temp2)
17892 delete arg2;
17893 }
17894 return resultobj;
17895 fail:
17896 {
17897 if (temp2)
17898 delete arg2;
17899 }
17900 return NULL;
17901 }
17902
17903
17904 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17905 PyObject *resultobj = 0;
17906 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17907 wxString *arg2 = 0 ;
17908 bool result;
17909 void *argp1 = 0 ;
17910 int res1 = 0 ;
17911 bool temp2 = false ;
17912 PyObject * obj0 = 0 ;
17913 PyObject * obj1 = 0 ;
17914 char * kwnames[] = {
17915 (char *) "self",(char *) "filename", NULL
17916 };
17917
17918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17920 if (!SWIG_IsOK(res1)) {
17921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17922 }
17923 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17924 {
17925 arg2 = wxString_in_helper(obj1);
17926 if (arg2 == NULL) SWIG_fail;
17927 temp2 = true;
17928 }
17929 {
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17932 wxPyEndAllowThreads(__tstate);
17933 if (PyErr_Occurred()) SWIG_fail;
17934 }
17935 {
17936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17937 }
17938 {
17939 if (temp2)
17940 delete arg2;
17941 }
17942 return resultobj;
17943 fail:
17944 {
17945 if (temp2)
17946 delete arg2;
17947 }
17948 return NULL;
17949 }
17950
17951
17952 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17953 PyObject *resultobj = 0;
17954 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17955 PyObject *result = 0 ;
17956 void *argp1 = 0 ;
17957 int res1 = 0 ;
17958 PyObject *swig_obj[1] ;
17959
17960 if (!args) SWIG_fail;
17961 swig_obj[0] = args;
17962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17963 if (!SWIG_IsOK(res1)) {
17964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17965 }
17966 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 resultobj = result;
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17981 PyObject *resultobj = 0;
17982 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17983 wxFileTypeInfo *arg2 = 0 ;
17984 void *argp1 = 0 ;
17985 int res1 = 0 ;
17986 void *argp2 = 0 ;
17987 int res2 = 0 ;
17988 PyObject * obj0 = 0 ;
17989 PyObject * obj1 = 0 ;
17990 char * kwnames[] = {
17991 (char *) "self",(char *) "ft", NULL
17992 };
17993
17994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17996 if (!SWIG_IsOK(res1)) {
17997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17998 }
17999 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18000 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18001 if (!SWIG_IsOK(res2)) {
18002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18003 }
18004 if (!argp2) {
18005 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18006 }
18007 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18011 wxPyEndAllowThreads(__tstate);
18012 if (PyErr_Occurred()) SWIG_fail;
18013 }
18014 resultobj = SWIG_Py_Void();
18015 return resultobj;
18016 fail:
18017 return NULL;
18018 }
18019
18020
18021 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18022 PyObject *resultobj = 0;
18023 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18024 wxFileTypeInfo *arg2 = 0 ;
18025 wxFileType *result = 0 ;
18026 void *argp1 = 0 ;
18027 int res1 = 0 ;
18028 void *argp2 = 0 ;
18029 int res2 = 0 ;
18030 PyObject * obj0 = 0 ;
18031 PyObject * obj1 = 0 ;
18032 char * kwnames[] = {
18033 (char *) "self",(char *) "ftInfo", NULL
18034 };
18035
18036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18038 if (!SWIG_IsOK(res1)) {
18039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18040 }
18041 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18043 if (!SWIG_IsOK(res2)) {
18044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18045 }
18046 if (!argp2) {
18047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18048 }
18049 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18050 {
18051 PyThreadState* __tstate = wxPyBeginAllowThreads();
18052 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18064 PyObject *resultobj = 0;
18065 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18066 wxFileType *arg2 = (wxFileType *) 0 ;
18067 bool result;
18068 void *argp1 = 0 ;
18069 int res1 = 0 ;
18070 void *argp2 = 0 ;
18071 int res2 = 0 ;
18072 PyObject * obj0 = 0 ;
18073 PyObject * obj1 = 0 ;
18074 char * kwnames[] = {
18075 (char *) "self",(char *) "ft", NULL
18076 };
18077
18078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
18079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18080 if (!SWIG_IsOK(res1)) {
18081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18082 }
18083 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
18085 if (!SWIG_IsOK(res2)) {
18086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
18087 }
18088 arg2 = reinterpret_cast< wxFileType * >(argp2);
18089 {
18090 PyThreadState* __tstate = wxPyBeginAllowThreads();
18091 result = (bool)(arg1)->Unassociate(arg2);
18092 wxPyEndAllowThreads(__tstate);
18093 if (PyErr_Occurred()) SWIG_fail;
18094 }
18095 {
18096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18097 }
18098 return resultobj;
18099 fail:
18100 return NULL;
18101 }
18102
18103
18104 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18105 PyObject *resultobj = 0;
18106 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18107 void *argp1 = 0 ;
18108 int res1 = 0 ;
18109 PyObject *swig_obj[1] ;
18110
18111 if (!args) SWIG_fail;
18112 swig_obj[0] = args;
18113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18116 }
18117 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 delete arg1;
18121
18122 wxPyEndAllowThreads(__tstate);
18123 if (PyErr_Occurred()) SWIG_fail;
18124 }
18125 resultobj = SWIG_Py_Void();
18126 return resultobj;
18127 fail:
18128 return NULL;
18129 }
18130
18131
18132 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18133 PyObject *obj;
18134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18135 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18136 return SWIG_Py_Void();
18137 }
18138
18139 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18140 return SWIG_Python_InitShadowInstance(args);
18141 }
18142
18143 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18144 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18145 return 1;
18146 }
18147
18148
18149 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18150 PyObject *pyobj = 0;
18151
18152 {
18153 #if wxUSE_UNICODE
18154 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18155 #else
18156 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18157 #endif
18158 }
18159 return pyobj;
18160 }
18161
18162
18163 SWIGINTERN int ART_MENU_set(PyObject *) {
18164 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18165 return 1;
18166 }
18167
18168
18169 SWIGINTERN PyObject *ART_MENU_get(void) {
18170 PyObject *pyobj = 0;
18171
18172 {
18173 #if wxUSE_UNICODE
18174 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18175 #else
18176 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18177 #endif
18178 }
18179 return pyobj;
18180 }
18181
18182
18183 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18184 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18185 return 1;
18186 }
18187
18188
18189 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18190 PyObject *pyobj = 0;
18191
18192 {
18193 #if wxUSE_UNICODE
18194 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18195 #else
18196 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18197 #endif
18198 }
18199 return pyobj;
18200 }
18201
18202
18203 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18204 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18205 return 1;
18206 }
18207
18208
18209 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18210 PyObject *pyobj = 0;
18211
18212 {
18213 #if wxUSE_UNICODE
18214 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18215 #else
18216 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18217 #endif
18218 }
18219 return pyobj;
18220 }
18221
18222
18223 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18224 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18225 return 1;
18226 }
18227
18228
18229 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18230 PyObject *pyobj = 0;
18231
18232 {
18233 #if wxUSE_UNICODE
18234 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18235 #else
18236 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18237 #endif
18238 }
18239 return pyobj;
18240 }
18241
18242
18243 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18244 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18245 return 1;
18246 }
18247
18248
18249 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18250 PyObject *pyobj = 0;
18251
18252 {
18253 #if wxUSE_UNICODE
18254 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18255 #else
18256 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18257 #endif
18258 }
18259 return pyobj;
18260 }
18261
18262
18263 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18264 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18265 return 1;
18266 }
18267
18268
18269 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18270 PyObject *pyobj = 0;
18271
18272 {
18273 #if wxUSE_UNICODE
18274 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18275 #else
18276 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18277 #endif
18278 }
18279 return pyobj;
18280 }
18281
18282
18283 SWIGINTERN int ART_OTHER_set(PyObject *) {
18284 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18285 return 1;
18286 }
18287
18288
18289 SWIGINTERN PyObject *ART_OTHER_get(void) {
18290 PyObject *pyobj = 0;
18291
18292 {
18293 #if wxUSE_UNICODE
18294 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18295 #else
18296 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18297 #endif
18298 }
18299 return pyobj;
18300 }
18301
18302
18303 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18304 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18305 return 1;
18306 }
18307
18308
18309 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18310 PyObject *pyobj = 0;
18311
18312 {
18313 #if wxUSE_UNICODE
18314 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18315 #else
18316 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18317 #endif
18318 }
18319 return pyobj;
18320 }
18321
18322
18323 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18324 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18325 return 1;
18326 }
18327
18328
18329 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18330 PyObject *pyobj = 0;
18331
18332 {
18333 #if wxUSE_UNICODE
18334 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18335 #else
18336 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18337 #endif
18338 }
18339 return pyobj;
18340 }
18341
18342
18343 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18344 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18345 return 1;
18346 }
18347
18348
18349 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18350 PyObject *pyobj = 0;
18351
18352 {
18353 #if wxUSE_UNICODE
18354 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18355 #else
18356 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18357 #endif
18358 }
18359 return pyobj;
18360 }
18361
18362
18363 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18364 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18365 return 1;
18366 }
18367
18368
18369 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18370 PyObject *pyobj = 0;
18371
18372 {
18373 #if wxUSE_UNICODE
18374 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18375 #else
18376 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18377 #endif
18378 }
18379 return pyobj;
18380 }
18381
18382
18383 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18384 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18385 return 1;
18386 }
18387
18388
18389 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18390 PyObject *pyobj = 0;
18391
18392 {
18393 #if wxUSE_UNICODE
18394 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18395 #else
18396 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18397 #endif
18398 }
18399 return pyobj;
18400 }
18401
18402
18403 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18404 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18405 return 1;
18406 }
18407
18408
18409 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18410 PyObject *pyobj = 0;
18411
18412 {
18413 #if wxUSE_UNICODE
18414 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18415 #else
18416 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18417 #endif
18418 }
18419 return pyobj;
18420 }
18421
18422
18423 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18424 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18425 return 1;
18426 }
18427
18428
18429 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18430 PyObject *pyobj = 0;
18431
18432 {
18433 #if wxUSE_UNICODE
18434 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18435 #else
18436 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18437 #endif
18438 }
18439 return pyobj;
18440 }
18441
18442
18443 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18444 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18445 return 1;
18446 }
18447
18448
18449 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18450 PyObject *pyobj = 0;
18451
18452 {
18453 #if wxUSE_UNICODE
18454 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18455 #else
18456 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18457 #endif
18458 }
18459 return pyobj;
18460 }
18461
18462
18463 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18464 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18465 return 1;
18466 }
18467
18468
18469 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18470 PyObject *pyobj = 0;
18471
18472 {
18473 #if wxUSE_UNICODE
18474 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18475 #else
18476 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18477 #endif
18478 }
18479 return pyobj;
18480 }
18481
18482
18483 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18484 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18485 return 1;
18486 }
18487
18488
18489 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18490 PyObject *pyobj = 0;
18491
18492 {
18493 #if wxUSE_UNICODE
18494 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18495 #else
18496 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18497 #endif
18498 }
18499 return pyobj;
18500 }
18501
18502
18503 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18504 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18505 return 1;
18506 }
18507
18508
18509 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18510 PyObject *pyobj = 0;
18511
18512 {
18513 #if wxUSE_UNICODE
18514 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18515 #else
18516 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18517 #endif
18518 }
18519 return pyobj;
18520 }
18521
18522
18523 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18524 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18525 return 1;
18526 }
18527
18528
18529 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18530 PyObject *pyobj = 0;
18531
18532 {
18533 #if wxUSE_UNICODE
18534 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18535 #else
18536 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18537 #endif
18538 }
18539 return pyobj;
18540 }
18541
18542
18543 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18544 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18545 return 1;
18546 }
18547
18548
18549 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18550 PyObject *pyobj = 0;
18551
18552 {
18553 #if wxUSE_UNICODE
18554 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18555 #else
18556 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18557 #endif
18558 }
18559 return pyobj;
18560 }
18561
18562
18563 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18564 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18565 return 1;
18566 }
18567
18568
18569 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18570 PyObject *pyobj = 0;
18571
18572 {
18573 #if wxUSE_UNICODE
18574 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18575 #else
18576 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18577 #endif
18578 }
18579 return pyobj;
18580 }
18581
18582
18583 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18584 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18585 return 1;
18586 }
18587
18588
18589 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18590 PyObject *pyobj = 0;
18591
18592 {
18593 #if wxUSE_UNICODE
18594 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18595 #else
18596 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18597 #endif
18598 }
18599 return pyobj;
18600 }
18601
18602
18603 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18604 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18605 return 1;
18606 }
18607
18608
18609 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18610 PyObject *pyobj = 0;
18611
18612 {
18613 #if wxUSE_UNICODE
18614 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18615 #else
18616 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18617 #endif
18618 }
18619 return pyobj;
18620 }
18621
18622
18623 SWIGINTERN int ART_PRINT_set(PyObject *) {
18624 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18625 return 1;
18626 }
18627
18628
18629 SWIGINTERN PyObject *ART_PRINT_get(void) {
18630 PyObject *pyobj = 0;
18631
18632 {
18633 #if wxUSE_UNICODE
18634 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18635 #else
18636 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18637 #endif
18638 }
18639 return pyobj;
18640 }
18641
18642
18643 SWIGINTERN int ART_HELP_set(PyObject *) {
18644 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18645 return 1;
18646 }
18647
18648
18649 SWIGINTERN PyObject *ART_HELP_get(void) {
18650 PyObject *pyobj = 0;
18651
18652 {
18653 #if wxUSE_UNICODE
18654 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18655 #else
18656 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18657 #endif
18658 }
18659 return pyobj;
18660 }
18661
18662
18663 SWIGINTERN int ART_TIP_set(PyObject *) {
18664 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18665 return 1;
18666 }
18667
18668
18669 SWIGINTERN PyObject *ART_TIP_get(void) {
18670 PyObject *pyobj = 0;
18671
18672 {
18673 #if wxUSE_UNICODE
18674 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18675 #else
18676 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18677 #endif
18678 }
18679 return pyobj;
18680 }
18681
18682
18683 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18684 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18685 return 1;
18686 }
18687
18688
18689 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18690 PyObject *pyobj = 0;
18691
18692 {
18693 #if wxUSE_UNICODE
18694 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18695 #else
18696 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18697 #endif
18698 }
18699 return pyobj;
18700 }
18701
18702
18703 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18704 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18705 return 1;
18706 }
18707
18708
18709 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18710 PyObject *pyobj = 0;
18711
18712 {
18713 #if wxUSE_UNICODE
18714 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18715 #else
18716 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18717 #endif
18718 }
18719 return pyobj;
18720 }
18721
18722
18723 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18724 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18725 return 1;
18726 }
18727
18728
18729 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18730 PyObject *pyobj = 0;
18731
18732 {
18733 #if wxUSE_UNICODE
18734 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18735 #else
18736 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18737 #endif
18738 }
18739 return pyobj;
18740 }
18741
18742
18743 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18744 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18745 return 1;
18746 }
18747
18748
18749 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18750 PyObject *pyobj = 0;
18751
18752 {
18753 #if wxUSE_UNICODE
18754 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18755 #else
18756 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18757 #endif
18758 }
18759 return pyobj;
18760 }
18761
18762
18763 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18764 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18765 return 1;
18766 }
18767
18768
18769 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18770 PyObject *pyobj = 0;
18771
18772 {
18773 #if wxUSE_UNICODE
18774 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18775 #else
18776 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18777 #endif
18778 }
18779 return pyobj;
18780 }
18781
18782
18783 SWIGINTERN int ART_CDROM_set(PyObject *) {
18784 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18785 return 1;
18786 }
18787
18788
18789 SWIGINTERN PyObject *ART_CDROM_get(void) {
18790 PyObject *pyobj = 0;
18791
18792 {
18793 #if wxUSE_UNICODE
18794 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18795 #else
18796 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18797 #endif
18798 }
18799 return pyobj;
18800 }
18801
18802
18803 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18804 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18805 return 1;
18806 }
18807
18808
18809 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18810 PyObject *pyobj = 0;
18811
18812 {
18813 #if wxUSE_UNICODE
18814 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18815 #else
18816 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18817 #endif
18818 }
18819 return pyobj;
18820 }
18821
18822
18823 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18824 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18825 return 1;
18826 }
18827
18828
18829 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18830 PyObject *pyobj = 0;
18831
18832 {
18833 #if wxUSE_UNICODE
18834 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18835 #else
18836 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18837 #endif
18838 }
18839 return pyobj;
18840 }
18841
18842
18843 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18844 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18845 return 1;
18846 }
18847
18848
18849 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18850 PyObject *pyobj = 0;
18851
18852 {
18853 #if wxUSE_UNICODE
18854 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18855 #else
18856 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18857 #endif
18858 }
18859 return pyobj;
18860 }
18861
18862
18863 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18864 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18865 return 1;
18866 }
18867
18868
18869 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18870 PyObject *pyobj = 0;
18871
18872 {
18873 #if wxUSE_UNICODE
18874 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18875 #else
18876 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18877 #endif
18878 }
18879 return pyobj;
18880 }
18881
18882
18883 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18884 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18885 return 1;
18886 }
18887
18888
18889 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18890 PyObject *pyobj = 0;
18891
18892 {
18893 #if wxUSE_UNICODE
18894 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18895 #else
18896 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18897 #endif
18898 }
18899 return pyobj;
18900 }
18901
18902
18903 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18904 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18905 return 1;
18906 }
18907
18908
18909 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18910 PyObject *pyobj = 0;
18911
18912 {
18913 #if wxUSE_UNICODE
18914 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18915 #else
18916 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18917 #endif
18918 }
18919 return pyobj;
18920 }
18921
18922
18923 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18924 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18925 return 1;
18926 }
18927
18928
18929 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18930 PyObject *pyobj = 0;
18931
18932 {
18933 #if wxUSE_UNICODE
18934 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18935 #else
18936 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18937 #endif
18938 }
18939 return pyobj;
18940 }
18941
18942
18943 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18944 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18945 return 1;
18946 }
18947
18948
18949 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18950 PyObject *pyobj = 0;
18951
18952 {
18953 #if wxUSE_UNICODE
18954 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18955 #else
18956 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18957 #endif
18958 }
18959 return pyobj;
18960 }
18961
18962
18963 SWIGINTERN int ART_ERROR_set(PyObject *) {
18964 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18965 return 1;
18966 }
18967
18968
18969 SWIGINTERN PyObject *ART_ERROR_get(void) {
18970 PyObject *pyobj = 0;
18971
18972 {
18973 #if wxUSE_UNICODE
18974 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18975 #else
18976 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18977 #endif
18978 }
18979 return pyobj;
18980 }
18981
18982
18983 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18984 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18985 return 1;
18986 }
18987
18988
18989 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18990 PyObject *pyobj = 0;
18991
18992 {
18993 #if wxUSE_UNICODE
18994 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18995 #else
18996 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18997 #endif
18998 }
18999 return pyobj;
19000 }
19001
19002
19003 SWIGINTERN int ART_WARNING_set(PyObject *) {
19004 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19005 return 1;
19006 }
19007
19008
19009 SWIGINTERN PyObject *ART_WARNING_get(void) {
19010 PyObject *pyobj = 0;
19011
19012 {
19013 #if wxUSE_UNICODE
19014 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19015 #else
19016 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19017 #endif
19018 }
19019 return pyobj;
19020 }
19021
19022
19023 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19024 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19025 return 1;
19026 }
19027
19028
19029 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19030 PyObject *pyobj = 0;
19031
19032 {
19033 #if wxUSE_UNICODE
19034 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19035 #else
19036 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19037 #endif
19038 }
19039 return pyobj;
19040 }
19041
19042
19043 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19044 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19045 return 1;
19046 }
19047
19048
19049 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19050 PyObject *pyobj = 0;
19051
19052 {
19053 #if wxUSE_UNICODE
19054 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19055 #else
19056 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19057 #endif
19058 }
19059 return pyobj;
19060 }
19061
19062
19063 SWIGINTERN int ART_COPY_set(PyObject *) {
19064 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
19065 return 1;
19066 }
19067
19068
19069 SWIGINTERN PyObject *ART_COPY_get(void) {
19070 PyObject *pyobj = 0;
19071
19072 {
19073 #if wxUSE_UNICODE
19074 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19075 #else
19076 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19077 #endif
19078 }
19079 return pyobj;
19080 }
19081
19082
19083 SWIGINTERN int ART_CUT_set(PyObject *) {
19084 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
19085 return 1;
19086 }
19087
19088
19089 SWIGINTERN PyObject *ART_CUT_get(void) {
19090 PyObject *pyobj = 0;
19091
19092 {
19093 #if wxUSE_UNICODE
19094 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19095 #else
19096 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19097 #endif
19098 }
19099 return pyobj;
19100 }
19101
19102
19103 SWIGINTERN int ART_PASTE_set(PyObject *) {
19104 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
19105 return 1;
19106 }
19107
19108
19109 SWIGINTERN PyObject *ART_PASTE_get(void) {
19110 PyObject *pyobj = 0;
19111
19112 {
19113 #if wxUSE_UNICODE
19114 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19115 #else
19116 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19117 #endif
19118 }
19119 return pyobj;
19120 }
19121
19122
19123 SWIGINTERN int ART_DELETE_set(PyObject *) {
19124 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19125 return 1;
19126 }
19127
19128
19129 SWIGINTERN PyObject *ART_DELETE_get(void) {
19130 PyObject *pyobj = 0;
19131
19132 {
19133 #if wxUSE_UNICODE
19134 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19135 #else
19136 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19137 #endif
19138 }
19139 return pyobj;
19140 }
19141
19142
19143 SWIGINTERN int ART_NEW_set(PyObject *) {
19144 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19145 return 1;
19146 }
19147
19148
19149 SWIGINTERN PyObject *ART_NEW_get(void) {
19150 PyObject *pyobj = 0;
19151
19152 {
19153 #if wxUSE_UNICODE
19154 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19155 #else
19156 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19157 #endif
19158 }
19159 return pyobj;
19160 }
19161
19162
19163 SWIGINTERN int ART_UNDO_set(PyObject *) {
19164 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19165 return 1;
19166 }
19167
19168
19169 SWIGINTERN PyObject *ART_UNDO_get(void) {
19170 PyObject *pyobj = 0;
19171
19172 {
19173 #if wxUSE_UNICODE
19174 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19175 #else
19176 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19177 #endif
19178 }
19179 return pyobj;
19180 }
19181
19182
19183 SWIGINTERN int ART_REDO_set(PyObject *) {
19184 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19185 return 1;
19186 }
19187
19188
19189 SWIGINTERN PyObject *ART_REDO_get(void) {
19190 PyObject *pyobj = 0;
19191
19192 {
19193 #if wxUSE_UNICODE
19194 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19195 #else
19196 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19197 #endif
19198 }
19199 return pyobj;
19200 }
19201
19202
19203 SWIGINTERN int ART_QUIT_set(PyObject *) {
19204 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19205 return 1;
19206 }
19207
19208
19209 SWIGINTERN PyObject *ART_QUIT_get(void) {
19210 PyObject *pyobj = 0;
19211
19212 {
19213 #if wxUSE_UNICODE
19214 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19215 #else
19216 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19217 #endif
19218 }
19219 return pyobj;
19220 }
19221
19222
19223 SWIGINTERN int ART_FIND_set(PyObject *) {
19224 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19225 return 1;
19226 }
19227
19228
19229 SWIGINTERN PyObject *ART_FIND_get(void) {
19230 PyObject *pyobj = 0;
19231
19232 {
19233 #if wxUSE_UNICODE
19234 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19235 #else
19236 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19237 #endif
19238 }
19239 return pyobj;
19240 }
19241
19242
19243 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19244 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19245 return 1;
19246 }
19247
19248
19249 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19250 PyObject *pyobj = 0;
19251
19252 {
19253 #if wxUSE_UNICODE
19254 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19255 #else
19256 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19257 #endif
19258 }
19259 return pyobj;
19260 }
19261
19262
19263 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19264 PyObject *resultobj = 0;
19265 wxPyArtProvider *result = 0 ;
19266
19267 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19268 {
19269 if (!wxPyCheckForApp()) SWIG_fail;
19270 PyThreadState* __tstate = wxPyBeginAllowThreads();
19271 result = (wxPyArtProvider *)new wxPyArtProvider();
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19276 return resultobj;
19277 fail:
19278 return NULL;
19279 }
19280
19281
19282 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19283 PyObject *resultobj = 0;
19284 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19285 void *argp1 = 0 ;
19286 int res1 = 0 ;
19287 PyObject *swig_obj[1] ;
19288
19289 if (!args) SWIG_fail;
19290 swig_obj[0] = args;
19291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19292 if (!SWIG_IsOK(res1)) {
19293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19294 }
19295 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19296 {
19297 PyThreadState* __tstate = wxPyBeginAllowThreads();
19298 delete arg1;
19299
19300 wxPyEndAllowThreads(__tstate);
19301 if (PyErr_Occurred()) SWIG_fail;
19302 }
19303 resultobj = SWIG_Py_Void();
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj = 0;
19312 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19313 PyObject *arg2 = (PyObject *) 0 ;
19314 PyObject *arg3 = (PyObject *) 0 ;
19315 void *argp1 = 0 ;
19316 int res1 = 0 ;
19317 PyObject * obj0 = 0 ;
19318 PyObject * obj1 = 0 ;
19319 PyObject * obj2 = 0 ;
19320 char * kwnames[] = {
19321 (char *) "self",(char *) "self",(char *) "_class", NULL
19322 };
19323
19324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19326 if (!SWIG_IsOK(res1)) {
19327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19328 }
19329 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19330 arg2 = obj1;
19331 arg3 = obj2;
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 (arg1)->_setCallbackInfo(arg2,arg3);
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 resultobj = SWIG_Py_Void();
19339 return resultobj;
19340 fail:
19341 return NULL;
19342 }
19343
19344
19345 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj = 0;
19347 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19348 int res1 = 0 ;
19349 PyObject * obj0 = 0 ;
19350 char * kwnames[] = {
19351 (char *) "provider", NULL
19352 };
19353
19354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19355 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19356 if (!SWIG_IsOK(res1)) {
19357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19358 }
19359 {
19360 PyThreadState* __tstate = wxPyBeginAllowThreads();
19361 wxPyArtProvider::PushProvider(arg1);
19362 wxPyEndAllowThreads(__tstate);
19363 if (PyErr_Occurred()) SWIG_fail;
19364 }
19365 resultobj = SWIG_Py_Void();
19366 return resultobj;
19367 fail:
19368 return NULL;
19369 }
19370
19371
19372 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19373 PyObject *resultobj = 0;
19374 bool result;
19375
19376 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (bool)wxPyArtProvider::PopProvider();
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 {
19384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19385 }
19386 return resultobj;
19387 fail:
19388 return NULL;
19389 }
19390
19391
19392 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19393 PyObject *resultobj = 0;
19394 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19395 bool result;
19396 void *argp1 = 0 ;
19397 int res1 = 0 ;
19398 PyObject * obj0 = 0 ;
19399 char * kwnames[] = {
19400 (char *) "provider", NULL
19401 };
19402
19403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19405 if (!SWIG_IsOK(res1)) {
19406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19407 }
19408 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19409 {
19410 PyThreadState* __tstate = wxPyBeginAllowThreads();
19411 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19412 wxPyEndAllowThreads(__tstate);
19413 if (PyErr_Occurred()) SWIG_fail;
19414 }
19415 {
19416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19417 }
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19425 PyObject *resultobj = 0;
19426 wxString *arg1 = 0 ;
19427 wxString const &arg2_defvalue = wxPyART_OTHER ;
19428 wxString *arg2 = (wxString *) &arg2_defvalue ;
19429 wxSize const &arg3_defvalue = wxDefaultSize ;
19430 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19431 wxBitmap result;
19432 bool temp1 = false ;
19433 bool temp2 = false ;
19434 wxSize temp3 ;
19435 PyObject * obj0 = 0 ;
19436 PyObject * obj1 = 0 ;
19437 PyObject * obj2 = 0 ;
19438 char * kwnames[] = {
19439 (char *) "id",(char *) "client",(char *) "size", NULL
19440 };
19441
19442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19443 {
19444 arg1 = wxString_in_helper(obj0);
19445 if (arg1 == NULL) SWIG_fail;
19446 temp1 = true;
19447 }
19448 if (obj1) {
19449 {
19450 arg2 = wxString_in_helper(obj1);
19451 if (arg2 == NULL) SWIG_fail;
19452 temp2 = true;
19453 }
19454 }
19455 if (obj2) {
19456 {
19457 arg3 = &temp3;
19458 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19459 }
19460 }
19461 {
19462 if (!wxPyCheckForApp()) SWIG_fail;
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19469 {
19470 if (temp1)
19471 delete arg1;
19472 }
19473 {
19474 if (temp2)
19475 delete arg2;
19476 }
19477 return resultobj;
19478 fail:
19479 {
19480 if (temp1)
19481 delete arg1;
19482 }
19483 {
19484 if (temp2)
19485 delete arg2;
19486 }
19487 return NULL;
19488 }
19489
19490
19491 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19492 PyObject *resultobj = 0;
19493 wxString *arg1 = 0 ;
19494 wxString const &arg2_defvalue = wxPyART_OTHER ;
19495 wxString *arg2 = (wxString *) &arg2_defvalue ;
19496 wxSize const &arg3_defvalue = wxDefaultSize ;
19497 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19498 wxIcon result;
19499 bool temp1 = false ;
19500 bool temp2 = false ;
19501 wxSize temp3 ;
19502 PyObject * obj0 = 0 ;
19503 PyObject * obj1 = 0 ;
19504 PyObject * obj2 = 0 ;
19505 char * kwnames[] = {
19506 (char *) "id",(char *) "client",(char *) "size", NULL
19507 };
19508
19509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19510 {
19511 arg1 = wxString_in_helper(obj0);
19512 if (arg1 == NULL) SWIG_fail;
19513 temp1 = true;
19514 }
19515 if (obj1) {
19516 {
19517 arg2 = wxString_in_helper(obj1);
19518 if (arg2 == NULL) SWIG_fail;
19519 temp2 = true;
19520 }
19521 }
19522 if (obj2) {
19523 {
19524 arg3 = &temp3;
19525 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19526 }
19527 }
19528 {
19529 if (!wxPyCheckForApp()) SWIG_fail;
19530 PyThreadState* __tstate = wxPyBeginAllowThreads();
19531 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19532 wxPyEndAllowThreads(__tstate);
19533 if (PyErr_Occurred()) SWIG_fail;
19534 }
19535 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19536 {
19537 if (temp1)
19538 delete arg1;
19539 }
19540 {
19541 if (temp2)
19542 delete arg2;
19543 }
19544 return resultobj;
19545 fail:
19546 {
19547 if (temp1)
19548 delete arg1;
19549 }
19550 {
19551 if (temp2)
19552 delete arg2;
19553 }
19554 return NULL;
19555 }
19556
19557
19558 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19559 PyObject *resultobj = 0;
19560 wxString *arg1 = 0 ;
19561 bool arg2 = (bool) false ;
19562 wxSize result;
19563 bool temp1 = false ;
19564 bool val2 ;
19565 int ecode2 = 0 ;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 char * kwnames[] = {
19569 (char *) "client",(char *) "platform_dependent", NULL
19570 };
19571
19572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19573 {
19574 arg1 = wxString_in_helper(obj0);
19575 if (arg1 == NULL) SWIG_fail;
19576 temp1 = true;
19577 }
19578 if (obj1) {
19579 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19580 if (!SWIG_IsOK(ecode2)) {
19581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19582 }
19583 arg2 = static_cast< bool >(val2);
19584 }
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19588 wxPyEndAllowThreads(__tstate);
19589 if (PyErr_Occurred()) SWIG_fail;
19590 }
19591 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19592 {
19593 if (temp1)
19594 delete arg1;
19595 }
19596 return resultobj;
19597 fail:
19598 {
19599 if (temp1)
19600 delete arg1;
19601 }
19602 return NULL;
19603 }
19604
19605
19606 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19607 PyObject *resultobj = 0;
19608 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19609 void *argp1 = 0 ;
19610 int res1 = 0 ;
19611 PyObject *swig_obj[1] ;
19612
19613 if (!args) SWIG_fail;
19614 swig_obj[0] = args;
19615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19616 if (!SWIG_IsOK(res1)) {
19617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19618 }
19619 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19620 {
19621 PyThreadState* __tstate = wxPyBeginAllowThreads();
19622 wxPyArtProvider_Destroy(arg1);
19623 wxPyEndAllowThreads(__tstate);
19624 if (PyErr_Occurred()) SWIG_fail;
19625 }
19626 resultobj = SWIG_Py_Void();
19627 return resultobj;
19628 fail:
19629 return NULL;
19630 }
19631
19632
19633 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19634 PyObject *obj;
19635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19636 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19637 return SWIG_Py_Void();
19638 }
19639
19640 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19641 return SWIG_Python_InitShadowInstance(args);
19642 }
19643
19644 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 PyObject *resultobj = 0;
19646 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19647 void *argp1 = 0 ;
19648 int res1 = 0 ;
19649 PyObject *swig_obj[1] ;
19650
19651 if (!args) SWIG_fail;
19652 swig_obj[0] = args;
19653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19654 if (!SWIG_IsOK(res1)) {
19655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19656 }
19657 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 delete arg1;
19661
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 resultobj = SWIG_Py_Void();
19666 return resultobj;
19667 fail:
19668 return NULL;
19669 }
19670
19671
19672 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19673 PyObject *resultobj = 0;
19674 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19675 wxConfigBase *result = 0 ;
19676 int res1 = 0 ;
19677 PyObject * obj0 = 0 ;
19678 char * kwnames[] = {
19679 (char *) "config", NULL
19680 };
19681
19682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19683 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19684 if (!SWIG_IsOK(res1)) {
19685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19686 }
19687 {
19688 PyThreadState* __tstate = wxPyBeginAllowThreads();
19689 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj = 0;
19702 bool arg1 = (bool) true ;
19703 wxConfigBase *result = 0 ;
19704 bool val1 ;
19705 int ecode1 = 0 ;
19706 PyObject * obj0 = 0 ;
19707 char * kwnames[] = {
19708 (char *) "createOnDemand", NULL
19709 };
19710
19711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19712 if (obj0) {
19713 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19714 if (!SWIG_IsOK(ecode1)) {
19715 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19716 }
19717 arg1 = static_cast< bool >(val1);
19718 }
19719 {
19720 PyThreadState* __tstate = wxPyBeginAllowThreads();
19721 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19722 wxPyEndAllowThreads(__tstate);
19723 if (PyErr_Occurred()) SWIG_fail;
19724 }
19725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19726 return resultobj;
19727 fail:
19728 return NULL;
19729 }
19730
19731
19732 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19733 PyObject *resultobj = 0;
19734 wxConfigBase *result = 0 ;
19735
19736 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19737 {
19738 PyThreadState* __tstate = wxPyBeginAllowThreads();
19739 result = (wxConfigBase *)wxConfigBase::Create();
19740 wxPyEndAllowThreads(__tstate);
19741 if (PyErr_Occurred()) SWIG_fail;
19742 }
19743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19744 return resultobj;
19745 fail:
19746 return NULL;
19747 }
19748
19749
19750 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19751 PyObject *resultobj = 0;
19752
19753 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19754 {
19755 PyThreadState* __tstate = wxPyBeginAllowThreads();
19756 wxConfigBase::DontCreateOnDemand();
19757 wxPyEndAllowThreads(__tstate);
19758 if (PyErr_Occurred()) SWIG_fail;
19759 }
19760 resultobj = SWIG_Py_Void();
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19768 PyObject *resultobj = 0;
19769 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19770 wxString *arg2 = 0 ;
19771 void *argp1 = 0 ;
19772 int res1 = 0 ;
19773 bool temp2 = false ;
19774 PyObject * obj0 = 0 ;
19775 PyObject * obj1 = 0 ;
19776 char * kwnames[] = {
19777 (char *) "self",(char *) "path", NULL
19778 };
19779
19780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19782 if (!SWIG_IsOK(res1)) {
19783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19784 }
19785 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19786 {
19787 arg2 = wxString_in_helper(obj1);
19788 if (arg2 == NULL) SWIG_fail;
19789 temp2 = true;
19790 }
19791 {
19792 PyThreadState* __tstate = wxPyBeginAllowThreads();
19793 (arg1)->SetPath((wxString const &)*arg2);
19794 wxPyEndAllowThreads(__tstate);
19795 if (PyErr_Occurred()) SWIG_fail;
19796 }
19797 resultobj = SWIG_Py_Void();
19798 {
19799 if (temp2)
19800 delete arg2;
19801 }
19802 return resultobj;
19803 fail:
19804 {
19805 if (temp2)
19806 delete arg2;
19807 }
19808 return NULL;
19809 }
19810
19811
19812 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19813 PyObject *resultobj = 0;
19814 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19815 wxString *result = 0 ;
19816 void *argp1 = 0 ;
19817 int res1 = 0 ;
19818 PyObject *swig_obj[1] ;
19819
19820 if (!args) SWIG_fail;
19821 swig_obj[0] = args;
19822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19825 }
19826 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 {
19830 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19831 result = (wxString *) &_result_ref;
19832 }
19833 wxPyEndAllowThreads(__tstate);
19834 if (PyErr_Occurred()) SWIG_fail;
19835 }
19836 {
19837 #if wxUSE_UNICODE
19838 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19839 #else
19840 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19841 #endif
19842 }
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19850 PyObject *resultobj = 0;
19851 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19852 PyObject *result = 0 ;
19853 void *argp1 = 0 ;
19854 int res1 = 0 ;
19855 PyObject *swig_obj[1] ;
19856
19857 if (!args) SWIG_fail;
19858 swig_obj[0] = args;
19859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19860 if (!SWIG_IsOK(res1)) {
19861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19862 }
19863 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19864 {
19865 PyThreadState* __tstate = wxPyBeginAllowThreads();
19866 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19867 wxPyEndAllowThreads(__tstate);
19868 if (PyErr_Occurred()) SWIG_fail;
19869 }
19870 resultobj = result;
19871 return resultobj;
19872 fail:
19873 return NULL;
19874 }
19875
19876
19877 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19878 PyObject *resultobj = 0;
19879 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19880 long arg2 ;
19881 PyObject *result = 0 ;
19882 void *argp1 = 0 ;
19883 int res1 = 0 ;
19884 long val2 ;
19885 int ecode2 = 0 ;
19886 PyObject * obj0 = 0 ;
19887 PyObject * obj1 = 0 ;
19888 char * kwnames[] = {
19889 (char *) "self",(char *) "index", NULL
19890 };
19891
19892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19894 if (!SWIG_IsOK(res1)) {
19895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19896 }
19897 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19898 ecode2 = SWIG_AsVal_long(obj1, &val2);
19899 if (!SWIG_IsOK(ecode2)) {
19900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19901 }
19902 arg2 = static_cast< long >(val2);
19903 {
19904 PyThreadState* __tstate = wxPyBeginAllowThreads();
19905 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19906 wxPyEndAllowThreads(__tstate);
19907 if (PyErr_Occurred()) SWIG_fail;
19908 }
19909 resultobj = result;
19910 return resultobj;
19911 fail:
19912 return NULL;
19913 }
19914
19915
19916 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19917 PyObject *resultobj = 0;
19918 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19919 PyObject *result = 0 ;
19920 void *argp1 = 0 ;
19921 int res1 = 0 ;
19922 PyObject *swig_obj[1] ;
19923
19924 if (!args) SWIG_fail;
19925 swig_obj[0] = args;
19926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19927 if (!SWIG_IsOK(res1)) {
19928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19929 }
19930 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19931 {
19932 PyThreadState* __tstate = wxPyBeginAllowThreads();
19933 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19934 wxPyEndAllowThreads(__tstate);
19935 if (PyErr_Occurred()) SWIG_fail;
19936 }
19937 resultobj = result;
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19945 PyObject *resultobj = 0;
19946 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19947 long arg2 ;
19948 PyObject *result = 0 ;
19949 void *argp1 = 0 ;
19950 int res1 = 0 ;
19951 long val2 ;
19952 int ecode2 = 0 ;
19953 PyObject * obj0 = 0 ;
19954 PyObject * obj1 = 0 ;
19955 char * kwnames[] = {
19956 (char *) "self",(char *) "index", NULL
19957 };
19958
19959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19961 if (!SWIG_IsOK(res1)) {
19962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19963 }
19964 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19965 ecode2 = SWIG_AsVal_long(obj1, &val2);
19966 if (!SWIG_IsOK(ecode2)) {
19967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19968 }
19969 arg2 = static_cast< long >(val2);
19970 {
19971 PyThreadState* __tstate = wxPyBeginAllowThreads();
19972 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19973 wxPyEndAllowThreads(__tstate);
19974 if (PyErr_Occurred()) SWIG_fail;
19975 }
19976 resultobj = result;
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19984 PyObject *resultobj = 0;
19985 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19986 bool arg2 = (bool) false ;
19987 size_t result;
19988 void *argp1 = 0 ;
19989 int res1 = 0 ;
19990 bool val2 ;
19991 int ecode2 = 0 ;
19992 PyObject * obj0 = 0 ;
19993 PyObject * obj1 = 0 ;
19994 char * kwnames[] = {
19995 (char *) "self",(char *) "recursive", NULL
19996 };
19997
19998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20000 if (!SWIG_IsOK(res1)) {
20001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20002 }
20003 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20004 if (obj1) {
20005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20006 if (!SWIG_IsOK(ecode2)) {
20007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20008 }
20009 arg2 = static_cast< bool >(val2);
20010 }
20011 {
20012 PyThreadState* __tstate = wxPyBeginAllowThreads();
20013 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20014 wxPyEndAllowThreads(__tstate);
20015 if (PyErr_Occurred()) SWIG_fail;
20016 }
20017 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20018 return resultobj;
20019 fail:
20020 return NULL;
20021 }
20022
20023
20024 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20025 PyObject *resultobj = 0;
20026 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20027 bool arg2 = (bool) false ;
20028 size_t result;
20029 void *argp1 = 0 ;
20030 int res1 = 0 ;
20031 bool val2 ;
20032 int ecode2 = 0 ;
20033 PyObject * obj0 = 0 ;
20034 PyObject * obj1 = 0 ;
20035 char * kwnames[] = {
20036 (char *) "self",(char *) "recursive", NULL
20037 };
20038
20039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20041 if (!SWIG_IsOK(res1)) {
20042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20043 }
20044 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20045 if (obj1) {
20046 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20047 if (!SWIG_IsOK(ecode2)) {
20048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
20049 }
20050 arg2 = static_cast< bool >(val2);
20051 }
20052 {
20053 PyThreadState* __tstate = wxPyBeginAllowThreads();
20054 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
20055 wxPyEndAllowThreads(__tstate);
20056 if (PyErr_Occurred()) SWIG_fail;
20057 }
20058 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20059 return resultobj;
20060 fail:
20061 return NULL;
20062 }
20063
20064
20065 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj = 0;
20067 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20068 wxString *arg2 = 0 ;
20069 bool result;
20070 void *argp1 = 0 ;
20071 int res1 = 0 ;
20072 bool temp2 = false ;
20073 PyObject * obj0 = 0 ;
20074 PyObject * obj1 = 0 ;
20075 char * kwnames[] = {
20076 (char *) "self",(char *) "name", NULL
20077 };
20078
20079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20081 if (!SWIG_IsOK(res1)) {
20082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20083 }
20084 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20085 {
20086 arg2 = wxString_in_helper(obj1);
20087 if (arg2 == NULL) SWIG_fail;
20088 temp2 = true;
20089 }
20090 {
20091 PyThreadState* __tstate = wxPyBeginAllowThreads();
20092 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
20093 wxPyEndAllowThreads(__tstate);
20094 if (PyErr_Occurred()) SWIG_fail;
20095 }
20096 {
20097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20098 }
20099 {
20100 if (temp2)
20101 delete arg2;
20102 }
20103 return resultobj;
20104 fail:
20105 {
20106 if (temp2)
20107 delete arg2;
20108 }
20109 return NULL;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20114 PyObject *resultobj = 0;
20115 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20116 wxString *arg2 = 0 ;
20117 bool result;
20118 void *argp1 = 0 ;
20119 int res1 = 0 ;
20120 bool temp2 = false ;
20121 PyObject * obj0 = 0 ;
20122 PyObject * obj1 = 0 ;
20123 char * kwnames[] = {
20124 (char *) "self",(char *) "name", NULL
20125 };
20126
20127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20129 if (!SWIG_IsOK(res1)) {
20130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20131 }
20132 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20133 {
20134 arg2 = wxString_in_helper(obj1);
20135 if (arg2 == NULL) SWIG_fail;
20136 temp2 = true;
20137 }
20138 {
20139 PyThreadState* __tstate = wxPyBeginAllowThreads();
20140 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20141 wxPyEndAllowThreads(__tstate);
20142 if (PyErr_Occurred()) SWIG_fail;
20143 }
20144 {
20145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20146 }
20147 {
20148 if (temp2)
20149 delete arg2;
20150 }
20151 return resultobj;
20152 fail:
20153 {
20154 if (temp2)
20155 delete arg2;
20156 }
20157 return NULL;
20158 }
20159
20160
20161 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20162 PyObject *resultobj = 0;
20163 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20164 wxString *arg2 = 0 ;
20165 bool result;
20166 void *argp1 = 0 ;
20167 int res1 = 0 ;
20168 bool temp2 = false ;
20169 PyObject * obj0 = 0 ;
20170 PyObject * obj1 = 0 ;
20171 char * kwnames[] = {
20172 (char *) "self",(char *) "name", NULL
20173 };
20174
20175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20177 if (!SWIG_IsOK(res1)) {
20178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20179 }
20180 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20181 {
20182 arg2 = wxString_in_helper(obj1);
20183 if (arg2 == NULL) SWIG_fail;
20184 temp2 = true;
20185 }
20186 {
20187 PyThreadState* __tstate = wxPyBeginAllowThreads();
20188 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20189 wxPyEndAllowThreads(__tstate);
20190 if (PyErr_Occurred()) SWIG_fail;
20191 }
20192 {
20193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20194 }
20195 {
20196 if (temp2)
20197 delete arg2;
20198 }
20199 return resultobj;
20200 fail:
20201 {
20202 if (temp2)
20203 delete arg2;
20204 }
20205 return NULL;
20206 }
20207
20208
20209 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20210 PyObject *resultobj = 0;
20211 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20212 wxString *arg2 = 0 ;
20213 wxConfigBase::EntryType result;
20214 void *argp1 = 0 ;
20215 int res1 = 0 ;
20216 bool temp2 = false ;
20217 PyObject * obj0 = 0 ;
20218 PyObject * obj1 = 0 ;
20219 char * kwnames[] = {
20220 (char *) "self",(char *) "name", NULL
20221 };
20222
20223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20225 if (!SWIG_IsOK(res1)) {
20226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20227 }
20228 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20229 {
20230 arg2 = wxString_in_helper(obj1);
20231 if (arg2 == NULL) SWIG_fail;
20232 temp2 = true;
20233 }
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_From_int(static_cast< int >(result));
20241 {
20242 if (temp2)
20243 delete arg2;
20244 }
20245 return resultobj;
20246 fail:
20247 {
20248 if (temp2)
20249 delete arg2;
20250 }
20251 return NULL;
20252 }
20253
20254
20255 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20256 PyObject *resultobj = 0;
20257 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20258 wxString *arg2 = 0 ;
20259 wxString const &arg3_defvalue = wxPyEmptyString ;
20260 wxString *arg3 = (wxString *) &arg3_defvalue ;
20261 wxString result;
20262 void *argp1 = 0 ;
20263 int res1 = 0 ;
20264 bool temp2 = false ;
20265 bool temp3 = false ;
20266 PyObject * obj0 = 0 ;
20267 PyObject * obj1 = 0 ;
20268 PyObject * obj2 = 0 ;
20269 char * kwnames[] = {
20270 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20271 };
20272
20273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20275 if (!SWIG_IsOK(res1)) {
20276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20277 }
20278 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20279 {
20280 arg2 = wxString_in_helper(obj1);
20281 if (arg2 == NULL) SWIG_fail;
20282 temp2 = true;
20283 }
20284 if (obj2) {
20285 {
20286 arg3 = wxString_in_helper(obj2);
20287 if (arg3 == NULL) SWIG_fail;
20288 temp3 = true;
20289 }
20290 }
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 {
20298 #if wxUSE_UNICODE
20299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20300 #else
20301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20302 #endif
20303 }
20304 {
20305 if (temp2)
20306 delete arg2;
20307 }
20308 {
20309 if (temp3)
20310 delete arg3;
20311 }
20312 return resultobj;
20313 fail:
20314 {
20315 if (temp2)
20316 delete arg2;
20317 }
20318 {
20319 if (temp3)
20320 delete arg3;
20321 }
20322 return NULL;
20323 }
20324
20325
20326 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20327 PyObject *resultobj = 0;
20328 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20329 wxString *arg2 = 0 ;
20330 long arg3 = (long) 0 ;
20331 long result;
20332 void *argp1 = 0 ;
20333 int res1 = 0 ;
20334 bool temp2 = false ;
20335 long val3 ;
20336 int ecode3 = 0 ;
20337 PyObject * obj0 = 0 ;
20338 PyObject * obj1 = 0 ;
20339 PyObject * obj2 = 0 ;
20340 char * kwnames[] = {
20341 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20342 };
20343
20344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20346 if (!SWIG_IsOK(res1)) {
20347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20348 }
20349 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20350 {
20351 arg2 = wxString_in_helper(obj1);
20352 if (arg2 == NULL) SWIG_fail;
20353 temp2 = true;
20354 }
20355 if (obj2) {
20356 ecode3 = SWIG_AsVal_long(obj2, &val3);
20357 if (!SWIG_IsOK(ecode3)) {
20358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20359 }
20360 arg3 = static_cast< long >(val3);
20361 }
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 resultobj = SWIG_From_long(static_cast< long >(result));
20369 {
20370 if (temp2)
20371 delete arg2;
20372 }
20373 return resultobj;
20374 fail:
20375 {
20376 if (temp2)
20377 delete arg2;
20378 }
20379 return NULL;
20380 }
20381
20382
20383 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20384 PyObject *resultobj = 0;
20385 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20386 wxString *arg2 = 0 ;
20387 double arg3 = (double) 0.0 ;
20388 double result;
20389 void *argp1 = 0 ;
20390 int res1 = 0 ;
20391 bool temp2 = false ;
20392 double val3 ;
20393 int ecode3 = 0 ;
20394 PyObject * obj0 = 0 ;
20395 PyObject * obj1 = 0 ;
20396 PyObject * obj2 = 0 ;
20397 char * kwnames[] = {
20398 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20399 };
20400
20401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20403 if (!SWIG_IsOK(res1)) {
20404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20405 }
20406 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20407 {
20408 arg2 = wxString_in_helper(obj1);
20409 if (arg2 == NULL) SWIG_fail;
20410 temp2 = true;
20411 }
20412 if (obj2) {
20413 ecode3 = SWIG_AsVal_double(obj2, &val3);
20414 if (!SWIG_IsOK(ecode3)) {
20415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20416 }
20417 arg3 = static_cast< double >(val3);
20418 }
20419 {
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 resultobj = SWIG_From_double(static_cast< double >(result));
20426 {
20427 if (temp2)
20428 delete arg2;
20429 }
20430 return resultobj;
20431 fail:
20432 {
20433 if (temp2)
20434 delete arg2;
20435 }
20436 return NULL;
20437 }
20438
20439
20440 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20441 PyObject *resultobj = 0;
20442 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20443 wxString *arg2 = 0 ;
20444 bool arg3 = (bool) false ;
20445 bool result;
20446 void *argp1 = 0 ;
20447 int res1 = 0 ;
20448 bool temp2 = false ;
20449 bool val3 ;
20450 int ecode3 = 0 ;
20451 PyObject * obj0 = 0 ;
20452 PyObject * obj1 = 0 ;
20453 PyObject * obj2 = 0 ;
20454 char * kwnames[] = {
20455 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20456 };
20457
20458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20460 if (!SWIG_IsOK(res1)) {
20461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20462 }
20463 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20464 {
20465 arg2 = wxString_in_helper(obj1);
20466 if (arg2 == NULL) SWIG_fail;
20467 temp2 = true;
20468 }
20469 if (obj2) {
20470 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20471 if (!SWIG_IsOK(ecode3)) {
20472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20473 }
20474 arg3 = static_cast< bool >(val3);
20475 }
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 {
20483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20484 }
20485 {
20486 if (temp2)
20487 delete arg2;
20488 }
20489 return resultobj;
20490 fail:
20491 {
20492 if (temp2)
20493 delete arg2;
20494 }
20495 return NULL;
20496 }
20497
20498
20499 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20500 PyObject *resultobj = 0;
20501 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20502 wxString *arg2 = 0 ;
20503 wxString *arg3 = 0 ;
20504 bool result;
20505 void *argp1 = 0 ;
20506 int res1 = 0 ;
20507 bool temp2 = false ;
20508 bool temp3 = false ;
20509 PyObject * obj0 = 0 ;
20510 PyObject * obj1 = 0 ;
20511 PyObject * obj2 = 0 ;
20512 char * kwnames[] = {
20513 (char *) "self",(char *) "key",(char *) "value", NULL
20514 };
20515
20516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20518 if (!SWIG_IsOK(res1)) {
20519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20520 }
20521 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20522 {
20523 arg2 = wxString_in_helper(obj1);
20524 if (arg2 == NULL) SWIG_fail;
20525 temp2 = true;
20526 }
20527 {
20528 arg3 = wxString_in_helper(obj2);
20529 if (arg3 == NULL) SWIG_fail;
20530 temp3 = true;
20531 }
20532 {
20533 PyThreadState* __tstate = wxPyBeginAllowThreads();
20534 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20540 }
20541 {
20542 if (temp2)
20543 delete arg2;
20544 }
20545 {
20546 if (temp3)
20547 delete arg3;
20548 }
20549 return resultobj;
20550 fail:
20551 {
20552 if (temp2)
20553 delete arg2;
20554 }
20555 {
20556 if (temp3)
20557 delete arg3;
20558 }
20559 return NULL;
20560 }
20561
20562
20563 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20564 PyObject *resultobj = 0;
20565 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20566 wxString *arg2 = 0 ;
20567 long arg3 ;
20568 bool result;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 bool temp2 = false ;
20572 long val3 ;
20573 int ecode3 = 0 ;
20574 PyObject * obj0 = 0 ;
20575 PyObject * obj1 = 0 ;
20576 PyObject * obj2 = 0 ;
20577 char * kwnames[] = {
20578 (char *) "self",(char *) "key",(char *) "value", NULL
20579 };
20580
20581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20583 if (!SWIG_IsOK(res1)) {
20584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20585 }
20586 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20587 {
20588 arg2 = wxString_in_helper(obj1);
20589 if (arg2 == NULL) SWIG_fail;
20590 temp2 = true;
20591 }
20592 ecode3 = SWIG_AsVal_long(obj2, &val3);
20593 if (!SWIG_IsOK(ecode3)) {
20594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20595 }
20596 arg3 = static_cast< long >(val3);
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 {
20604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20605 }
20606 {
20607 if (temp2)
20608 delete arg2;
20609 }
20610 return resultobj;
20611 fail:
20612 {
20613 if (temp2)
20614 delete arg2;
20615 }
20616 return NULL;
20617 }
20618
20619
20620 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj = 0;
20622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20623 wxString *arg2 = 0 ;
20624 double arg3 ;
20625 bool result;
20626 void *argp1 = 0 ;
20627 int res1 = 0 ;
20628 bool temp2 = false ;
20629 double val3 ;
20630 int ecode3 = 0 ;
20631 PyObject * obj0 = 0 ;
20632 PyObject * obj1 = 0 ;
20633 PyObject * obj2 = 0 ;
20634 char * kwnames[] = {
20635 (char *) "self",(char *) "key",(char *) "value", NULL
20636 };
20637
20638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20640 if (!SWIG_IsOK(res1)) {
20641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20642 }
20643 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20644 {
20645 arg2 = wxString_in_helper(obj1);
20646 if (arg2 == NULL) SWIG_fail;
20647 temp2 = true;
20648 }
20649 ecode3 = SWIG_AsVal_double(obj2, &val3);
20650 if (!SWIG_IsOK(ecode3)) {
20651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20652 }
20653 arg3 = static_cast< double >(val3);
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 {
20661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20662 }
20663 {
20664 if (temp2)
20665 delete arg2;
20666 }
20667 return resultobj;
20668 fail:
20669 {
20670 if (temp2)
20671 delete arg2;
20672 }
20673 return NULL;
20674 }
20675
20676
20677 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20678 PyObject *resultobj = 0;
20679 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20680 wxString *arg2 = 0 ;
20681 bool arg3 ;
20682 bool result;
20683 void *argp1 = 0 ;
20684 int res1 = 0 ;
20685 bool temp2 = false ;
20686 bool val3 ;
20687 int ecode3 = 0 ;
20688 PyObject * obj0 = 0 ;
20689 PyObject * obj1 = 0 ;
20690 PyObject * obj2 = 0 ;
20691 char * kwnames[] = {
20692 (char *) "self",(char *) "key",(char *) "value", NULL
20693 };
20694
20695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20697 if (!SWIG_IsOK(res1)) {
20698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20699 }
20700 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20701 {
20702 arg2 = wxString_in_helper(obj1);
20703 if (arg2 == NULL) SWIG_fail;
20704 temp2 = true;
20705 }
20706 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20707 if (!SWIG_IsOK(ecode3)) {
20708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20709 }
20710 arg3 = static_cast< bool >(val3);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 {
20718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20719 }
20720 {
20721 if (temp2)
20722 delete arg2;
20723 }
20724 return resultobj;
20725 fail:
20726 {
20727 if (temp2)
20728 delete arg2;
20729 }
20730 return NULL;
20731 }
20732
20733
20734 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj = 0;
20736 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20737 bool arg2 = (bool) false ;
20738 bool result;
20739 void *argp1 = 0 ;
20740 int res1 = 0 ;
20741 bool val2 ;
20742 int ecode2 = 0 ;
20743 PyObject * obj0 = 0 ;
20744 PyObject * obj1 = 0 ;
20745 char * kwnames[] = {
20746 (char *) "self",(char *) "currentOnly", NULL
20747 };
20748
20749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20751 if (!SWIG_IsOK(res1)) {
20752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20753 }
20754 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20755 if (obj1) {
20756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20757 if (!SWIG_IsOK(ecode2)) {
20758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20759 }
20760 arg2 = static_cast< bool >(val2);
20761 }
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 result = (bool)(arg1)->Flush(arg2);
20765 wxPyEndAllowThreads(__tstate);
20766 if (PyErr_Occurred()) SWIG_fail;
20767 }
20768 {
20769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20770 }
20771 return resultobj;
20772 fail:
20773 return NULL;
20774 }
20775
20776
20777 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20778 PyObject *resultobj = 0;
20779 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20780 wxString *arg2 = 0 ;
20781 wxString *arg3 = 0 ;
20782 bool result;
20783 void *argp1 = 0 ;
20784 int res1 = 0 ;
20785 bool temp2 = false ;
20786 bool temp3 = false ;
20787 PyObject * obj0 = 0 ;
20788 PyObject * obj1 = 0 ;
20789 PyObject * obj2 = 0 ;
20790 char * kwnames[] = {
20791 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20792 };
20793
20794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20796 if (!SWIG_IsOK(res1)) {
20797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20798 }
20799 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20800 {
20801 arg2 = wxString_in_helper(obj1);
20802 if (arg2 == NULL) SWIG_fail;
20803 temp2 = true;
20804 }
20805 {
20806 arg3 = wxString_in_helper(obj2);
20807 if (arg3 == NULL) SWIG_fail;
20808 temp3 = true;
20809 }
20810 {
20811 PyThreadState* __tstate = wxPyBeginAllowThreads();
20812 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20813 wxPyEndAllowThreads(__tstate);
20814 if (PyErr_Occurred()) SWIG_fail;
20815 }
20816 {
20817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20818 }
20819 {
20820 if (temp2)
20821 delete arg2;
20822 }
20823 {
20824 if (temp3)
20825 delete arg3;
20826 }
20827 return resultobj;
20828 fail:
20829 {
20830 if (temp2)
20831 delete arg2;
20832 }
20833 {
20834 if (temp3)
20835 delete arg3;
20836 }
20837 return NULL;
20838 }
20839
20840
20841 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(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_RenameGroup",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_RenameGroup" "', 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)->RenameGroup((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_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20906 PyObject *resultobj = 0;
20907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20908 wxString *arg2 = 0 ;
20909 bool arg3 = (bool) true ;
20910 bool result;
20911 void *argp1 = 0 ;
20912 int res1 = 0 ;
20913 bool temp2 = false ;
20914 bool val3 ;
20915 int ecode3 = 0 ;
20916 PyObject * obj0 = 0 ;
20917 PyObject * obj1 = 0 ;
20918 PyObject * obj2 = 0 ;
20919 char * kwnames[] = {
20920 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20921 };
20922
20923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20927 }
20928 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20929 {
20930 arg2 = wxString_in_helper(obj1);
20931 if (arg2 == NULL) SWIG_fail;
20932 temp2 = true;
20933 }
20934 if (obj2) {
20935 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20936 if (!SWIG_IsOK(ecode3)) {
20937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20938 }
20939 arg3 = static_cast< bool >(val3);
20940 }
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 {
20948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20949 }
20950 {
20951 if (temp2)
20952 delete arg2;
20953 }
20954 return resultobj;
20955 fail:
20956 {
20957 if (temp2)
20958 delete arg2;
20959 }
20960 return NULL;
20961 }
20962
20963
20964 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20965 PyObject *resultobj = 0;
20966 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20967 wxString *arg2 = 0 ;
20968 bool result;
20969 void *argp1 = 0 ;
20970 int res1 = 0 ;
20971 bool temp2 = false ;
20972 PyObject * obj0 = 0 ;
20973 PyObject * obj1 = 0 ;
20974 char * kwnames[] = {
20975 (char *) "self",(char *) "key", NULL
20976 };
20977
20978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20980 if (!SWIG_IsOK(res1)) {
20981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20982 }
20983 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20984 {
20985 arg2 = wxString_in_helper(obj1);
20986 if (arg2 == NULL) SWIG_fail;
20987 temp2 = true;
20988 }
20989 {
20990 PyThreadState* __tstate = wxPyBeginAllowThreads();
20991 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20992 wxPyEndAllowThreads(__tstate);
20993 if (PyErr_Occurred()) SWIG_fail;
20994 }
20995 {
20996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20997 }
20998 {
20999 if (temp2)
21000 delete arg2;
21001 }
21002 return resultobj;
21003 fail:
21004 {
21005 if (temp2)
21006 delete arg2;
21007 }
21008 return NULL;
21009 }
21010
21011
21012 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21013 PyObject *resultobj = 0;
21014 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21015 bool result;
21016 void *argp1 = 0 ;
21017 int res1 = 0 ;
21018 PyObject *swig_obj[1] ;
21019
21020 if (!args) SWIG_fail;
21021 swig_obj[0] = args;
21022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21023 if (!SWIG_IsOK(res1)) {
21024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21025 }
21026 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21027 {
21028 PyThreadState* __tstate = wxPyBeginAllowThreads();
21029 result = (bool)(arg1)->DeleteAll();
21030 wxPyEndAllowThreads(__tstate);
21031 if (PyErr_Occurred()) SWIG_fail;
21032 }
21033 {
21034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21035 }
21036 return resultobj;
21037 fail:
21038 return NULL;
21039 }
21040
21041
21042 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21043 PyObject *resultobj = 0;
21044 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21045 bool arg2 = (bool) true ;
21046 void *argp1 = 0 ;
21047 int res1 = 0 ;
21048 bool val2 ;
21049 int ecode2 = 0 ;
21050 PyObject * obj0 = 0 ;
21051 PyObject * obj1 = 0 ;
21052 char * kwnames[] = {
21053 (char *) "self",(char *) "doIt", NULL
21054 };
21055
21056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21058 if (!SWIG_IsOK(res1)) {
21059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21060 }
21061 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21062 if (obj1) {
21063 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21064 if (!SWIG_IsOK(ecode2)) {
21065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
21066 }
21067 arg2 = static_cast< bool >(val2);
21068 }
21069 {
21070 PyThreadState* __tstate = wxPyBeginAllowThreads();
21071 (arg1)->SetExpandEnvVars(arg2);
21072 wxPyEndAllowThreads(__tstate);
21073 if (PyErr_Occurred()) SWIG_fail;
21074 }
21075 resultobj = SWIG_Py_Void();
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21083 PyObject *resultobj = 0;
21084 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21085 bool result;
21086 void *argp1 = 0 ;
21087 int res1 = 0 ;
21088 PyObject *swig_obj[1] ;
21089
21090 if (!args) SWIG_fail;
21091 swig_obj[0] = args;
21092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21093 if (!SWIG_IsOK(res1)) {
21094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21095 }
21096 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
21100 wxPyEndAllowThreads(__tstate);
21101 if (PyErr_Occurred()) SWIG_fail;
21102 }
21103 {
21104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21105 }
21106 return resultobj;
21107 fail:
21108 return NULL;
21109 }
21110
21111
21112 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21113 PyObject *resultobj = 0;
21114 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21115 bool arg2 = (bool) true ;
21116 void *argp1 = 0 ;
21117 int res1 = 0 ;
21118 bool val2 ;
21119 int ecode2 = 0 ;
21120 PyObject * obj0 = 0 ;
21121 PyObject * obj1 = 0 ;
21122 char * kwnames[] = {
21123 (char *) "self",(char *) "doIt", NULL
21124 };
21125
21126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21128 if (!SWIG_IsOK(res1)) {
21129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21130 }
21131 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21132 if (obj1) {
21133 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21134 if (!SWIG_IsOK(ecode2)) {
21135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21136 }
21137 arg2 = static_cast< bool >(val2);
21138 }
21139 {
21140 PyThreadState* __tstate = wxPyBeginAllowThreads();
21141 (arg1)->SetRecordDefaults(arg2);
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 resultobj = SWIG_Py_Void();
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *resultobj = 0;
21154 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21155 bool result;
21156 void *argp1 = 0 ;
21157 int res1 = 0 ;
21158 PyObject *swig_obj[1] ;
21159
21160 if (!args) SWIG_fail;
21161 swig_obj[0] = args;
21162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21163 if (!SWIG_IsOK(res1)) {
21164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21165 }
21166 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21167 {
21168 PyThreadState* __tstate = wxPyBeginAllowThreads();
21169 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 {
21174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21175 }
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21183 PyObject *resultobj = 0;
21184 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21185 wxString *arg2 = 0 ;
21186 wxString result;
21187 void *argp1 = 0 ;
21188 int res1 = 0 ;
21189 bool temp2 = false ;
21190 PyObject * obj0 = 0 ;
21191 PyObject * obj1 = 0 ;
21192 char * kwnames[] = {
21193 (char *) "self",(char *) "str", NULL
21194 };
21195
21196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21200 }
21201 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21202 {
21203 arg2 = wxString_in_helper(obj1);
21204 if (arg2 == NULL) SWIG_fail;
21205 temp2 = true;
21206 }
21207 {
21208 PyThreadState* __tstate = wxPyBeginAllowThreads();
21209 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21210 wxPyEndAllowThreads(__tstate);
21211 if (PyErr_Occurred()) SWIG_fail;
21212 }
21213 {
21214 #if wxUSE_UNICODE
21215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21216 #else
21217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21218 #endif
21219 }
21220 {
21221 if (temp2)
21222 delete arg2;
21223 }
21224 return resultobj;
21225 fail:
21226 {
21227 if (temp2)
21228 delete arg2;
21229 }
21230 return NULL;
21231 }
21232
21233
21234 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21235 PyObject *resultobj = 0;
21236 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21237 wxString result;
21238 void *argp1 = 0 ;
21239 int res1 = 0 ;
21240 PyObject *swig_obj[1] ;
21241
21242 if (!args) SWIG_fail;
21243 swig_obj[0] = args;
21244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21245 if (!SWIG_IsOK(res1)) {
21246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21247 }
21248 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21249 {
21250 PyThreadState* __tstate = wxPyBeginAllowThreads();
21251 result = ((wxConfigBase const *)arg1)->GetAppName();
21252 wxPyEndAllowThreads(__tstate);
21253 if (PyErr_Occurred()) SWIG_fail;
21254 }
21255 {
21256 #if wxUSE_UNICODE
21257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21258 #else
21259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21260 #endif
21261 }
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21269 PyObject *resultobj = 0;
21270 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21271 wxString result;
21272 void *argp1 = 0 ;
21273 int res1 = 0 ;
21274 PyObject *swig_obj[1] ;
21275
21276 if (!args) SWIG_fail;
21277 swig_obj[0] = args;
21278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21279 if (!SWIG_IsOK(res1)) {
21280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21281 }
21282 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21283 {
21284 PyThreadState* __tstate = wxPyBeginAllowThreads();
21285 result = ((wxConfigBase const *)arg1)->GetVendorName();
21286 wxPyEndAllowThreads(__tstate);
21287 if (PyErr_Occurred()) SWIG_fail;
21288 }
21289 {
21290 #if wxUSE_UNICODE
21291 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21292 #else
21293 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21294 #endif
21295 }
21296 return resultobj;
21297 fail:
21298 return NULL;
21299 }
21300
21301
21302 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21303 PyObject *resultobj = 0;
21304 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21305 wxString *arg2 = 0 ;
21306 void *argp1 = 0 ;
21307 int res1 = 0 ;
21308 bool temp2 = false ;
21309 PyObject * obj0 = 0 ;
21310 PyObject * obj1 = 0 ;
21311 char * kwnames[] = {
21312 (char *) "self",(char *) "appName", NULL
21313 };
21314
21315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21317 if (!SWIG_IsOK(res1)) {
21318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21319 }
21320 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21321 {
21322 arg2 = wxString_in_helper(obj1);
21323 if (arg2 == NULL) SWIG_fail;
21324 temp2 = true;
21325 }
21326 {
21327 PyThreadState* __tstate = wxPyBeginAllowThreads();
21328 (arg1)->SetAppName((wxString const &)*arg2);
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 resultobj = SWIG_Py_Void();
21333 {
21334 if (temp2)
21335 delete arg2;
21336 }
21337 return resultobj;
21338 fail:
21339 {
21340 if (temp2)
21341 delete arg2;
21342 }
21343 return NULL;
21344 }
21345
21346
21347 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21348 PyObject *resultobj = 0;
21349 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21350 wxString *arg2 = 0 ;
21351 void *argp1 = 0 ;
21352 int res1 = 0 ;
21353 bool temp2 = false ;
21354 PyObject * obj0 = 0 ;
21355 PyObject * obj1 = 0 ;
21356 char * kwnames[] = {
21357 (char *) "self",(char *) "vendorName", NULL
21358 };
21359
21360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21362 if (!SWIG_IsOK(res1)) {
21363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21364 }
21365 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21366 {
21367 arg2 = wxString_in_helper(obj1);
21368 if (arg2 == NULL) SWIG_fail;
21369 temp2 = true;
21370 }
21371 {
21372 PyThreadState* __tstate = wxPyBeginAllowThreads();
21373 (arg1)->SetVendorName((wxString const &)*arg2);
21374 wxPyEndAllowThreads(__tstate);
21375 if (PyErr_Occurred()) SWIG_fail;
21376 }
21377 resultobj = SWIG_Py_Void();
21378 {
21379 if (temp2)
21380 delete arg2;
21381 }
21382 return resultobj;
21383 fail:
21384 {
21385 if (temp2)
21386 delete arg2;
21387 }
21388 return NULL;
21389 }
21390
21391
21392 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21393 PyObject *resultobj = 0;
21394 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21395 long arg2 ;
21396 void *argp1 = 0 ;
21397 int res1 = 0 ;
21398 long val2 ;
21399 int ecode2 = 0 ;
21400 PyObject * obj0 = 0 ;
21401 PyObject * obj1 = 0 ;
21402 char * kwnames[] = {
21403 (char *) "self",(char *) "style", NULL
21404 };
21405
21406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21408 if (!SWIG_IsOK(res1)) {
21409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21410 }
21411 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21412 ecode2 = SWIG_AsVal_long(obj1, &val2);
21413 if (!SWIG_IsOK(ecode2)) {
21414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21415 }
21416 arg2 = static_cast< long >(val2);
21417 {
21418 PyThreadState* __tstate = wxPyBeginAllowThreads();
21419 (arg1)->SetStyle(arg2);
21420 wxPyEndAllowThreads(__tstate);
21421 if (PyErr_Occurred()) SWIG_fail;
21422 }
21423 resultobj = SWIG_Py_Void();
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21431 PyObject *resultobj = 0;
21432 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21433 long result;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 PyObject *swig_obj[1] ;
21437
21438 if (!args) SWIG_fail;
21439 swig_obj[0] = args;
21440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21441 if (!SWIG_IsOK(res1)) {
21442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21443 }
21444 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21445 {
21446 PyThreadState* __tstate = wxPyBeginAllowThreads();
21447 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21448 wxPyEndAllowThreads(__tstate);
21449 if (PyErr_Occurred()) SWIG_fail;
21450 }
21451 resultobj = SWIG_From_long(static_cast< long >(result));
21452 return resultobj;
21453 fail:
21454 return NULL;
21455 }
21456
21457
21458 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21459 PyObject *obj;
21460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21461 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21462 return SWIG_Py_Void();
21463 }
21464
21465 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21466 PyObject *resultobj = 0;
21467 wxString const &arg1_defvalue = wxPyEmptyString ;
21468 wxString *arg1 = (wxString *) &arg1_defvalue ;
21469 wxString const &arg2_defvalue = wxPyEmptyString ;
21470 wxString *arg2 = (wxString *) &arg2_defvalue ;
21471 wxString const &arg3_defvalue = wxPyEmptyString ;
21472 wxString *arg3 = (wxString *) &arg3_defvalue ;
21473 wxString const &arg4_defvalue = wxPyEmptyString ;
21474 wxString *arg4 = (wxString *) &arg4_defvalue ;
21475 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21476 wxConfig *result = 0 ;
21477 bool temp1 = false ;
21478 bool temp2 = false ;
21479 bool temp3 = false ;
21480 bool temp4 = false ;
21481 long val5 ;
21482 int ecode5 = 0 ;
21483 PyObject * obj0 = 0 ;
21484 PyObject * obj1 = 0 ;
21485 PyObject * obj2 = 0 ;
21486 PyObject * obj3 = 0 ;
21487 PyObject * obj4 = 0 ;
21488 char * kwnames[] = {
21489 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21490 };
21491
21492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21493 if (obj0) {
21494 {
21495 arg1 = wxString_in_helper(obj0);
21496 if (arg1 == NULL) SWIG_fail;
21497 temp1 = true;
21498 }
21499 }
21500 if (obj1) {
21501 {
21502 arg2 = wxString_in_helper(obj1);
21503 if (arg2 == NULL) SWIG_fail;
21504 temp2 = true;
21505 }
21506 }
21507 if (obj2) {
21508 {
21509 arg3 = wxString_in_helper(obj2);
21510 if (arg3 == NULL) SWIG_fail;
21511 temp3 = true;
21512 }
21513 }
21514 if (obj3) {
21515 {
21516 arg4 = wxString_in_helper(obj3);
21517 if (arg4 == NULL) SWIG_fail;
21518 temp4 = true;
21519 }
21520 }
21521 if (obj4) {
21522 ecode5 = SWIG_AsVal_long(obj4, &val5);
21523 if (!SWIG_IsOK(ecode5)) {
21524 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21525 }
21526 arg5 = static_cast< long >(val5);
21527 }
21528 {
21529 PyThreadState* __tstate = wxPyBeginAllowThreads();
21530 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21531 wxPyEndAllowThreads(__tstate);
21532 if (PyErr_Occurred()) SWIG_fail;
21533 }
21534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21535 {
21536 if (temp1)
21537 delete arg1;
21538 }
21539 {
21540 if (temp2)
21541 delete arg2;
21542 }
21543 {
21544 if (temp3)
21545 delete arg3;
21546 }
21547 {
21548 if (temp4)
21549 delete arg4;
21550 }
21551 return resultobj;
21552 fail:
21553 {
21554 if (temp1)
21555 delete arg1;
21556 }
21557 {
21558 if (temp2)
21559 delete arg2;
21560 }
21561 {
21562 if (temp3)
21563 delete arg3;
21564 }
21565 {
21566 if (temp4)
21567 delete arg4;
21568 }
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxConfig *arg1 = (wxConfig *) 0 ;
21576 void *argp1 = 0 ;
21577 int res1 = 0 ;
21578 PyObject *swig_obj[1] ;
21579
21580 if (!args) SWIG_fail;
21581 swig_obj[0] = args;
21582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21583 if (!SWIG_IsOK(res1)) {
21584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21585 }
21586 arg1 = reinterpret_cast< wxConfig * >(argp1);
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 delete arg1;
21590
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 resultobj = SWIG_Py_Void();
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21602 PyObject *obj;
21603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21604 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21605 return SWIG_Py_Void();
21606 }
21607
21608 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21609 return SWIG_Python_InitShadowInstance(args);
21610 }
21611
21612 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21613 PyObject *resultobj = 0;
21614 wxString const &arg1_defvalue = wxPyEmptyString ;
21615 wxString *arg1 = (wxString *) &arg1_defvalue ;
21616 wxString const &arg2_defvalue = wxPyEmptyString ;
21617 wxString *arg2 = (wxString *) &arg2_defvalue ;
21618 wxString const &arg3_defvalue = wxPyEmptyString ;
21619 wxString *arg3 = (wxString *) &arg3_defvalue ;
21620 wxString const &arg4_defvalue = wxPyEmptyString ;
21621 wxString *arg4 = (wxString *) &arg4_defvalue ;
21622 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21623 wxFileConfig *result = 0 ;
21624 bool temp1 = false ;
21625 bool temp2 = false ;
21626 bool temp3 = false ;
21627 bool temp4 = false ;
21628 long val5 ;
21629 int ecode5 = 0 ;
21630 PyObject * obj0 = 0 ;
21631 PyObject * obj1 = 0 ;
21632 PyObject * obj2 = 0 ;
21633 PyObject * obj3 = 0 ;
21634 PyObject * obj4 = 0 ;
21635 char * kwnames[] = {
21636 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21637 };
21638
21639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21640 if (obj0) {
21641 {
21642 arg1 = wxString_in_helper(obj0);
21643 if (arg1 == NULL) SWIG_fail;
21644 temp1 = true;
21645 }
21646 }
21647 if (obj1) {
21648 {
21649 arg2 = wxString_in_helper(obj1);
21650 if (arg2 == NULL) SWIG_fail;
21651 temp2 = true;
21652 }
21653 }
21654 if (obj2) {
21655 {
21656 arg3 = wxString_in_helper(obj2);
21657 if (arg3 == NULL) SWIG_fail;
21658 temp3 = true;
21659 }
21660 }
21661 if (obj3) {
21662 {
21663 arg4 = wxString_in_helper(obj3);
21664 if (arg4 == NULL) SWIG_fail;
21665 temp4 = true;
21666 }
21667 }
21668 if (obj4) {
21669 ecode5 = SWIG_AsVal_long(obj4, &val5);
21670 if (!SWIG_IsOK(ecode5)) {
21671 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21672 }
21673 arg5 = static_cast< long >(val5);
21674 }
21675 {
21676 PyThreadState* __tstate = wxPyBeginAllowThreads();
21677 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21678 wxPyEndAllowThreads(__tstate);
21679 if (PyErr_Occurred()) SWIG_fail;
21680 }
21681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21682 {
21683 if (temp1)
21684 delete arg1;
21685 }
21686 {
21687 if (temp2)
21688 delete arg2;
21689 }
21690 {
21691 if (temp3)
21692 delete arg3;
21693 }
21694 {
21695 if (temp4)
21696 delete arg4;
21697 }
21698 return resultobj;
21699 fail:
21700 {
21701 if (temp1)
21702 delete arg1;
21703 }
21704 {
21705 if (temp2)
21706 delete arg2;
21707 }
21708 {
21709 if (temp3)
21710 delete arg3;
21711 }
21712 {
21713 if (temp4)
21714 delete arg4;
21715 }
21716 return NULL;
21717 }
21718
21719
21720 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21721 PyObject *resultobj = 0;
21722 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21723 void *argp1 = 0 ;
21724 int res1 = 0 ;
21725 PyObject *swig_obj[1] ;
21726
21727 if (!args) SWIG_fail;
21728 swig_obj[0] = args;
21729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21730 if (!SWIG_IsOK(res1)) {
21731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21732 }
21733 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 delete arg1;
21737
21738 wxPyEndAllowThreads(__tstate);
21739 if (PyErr_Occurred()) SWIG_fail;
21740 }
21741 resultobj = SWIG_Py_Void();
21742 return resultobj;
21743 fail:
21744 return NULL;
21745 }
21746
21747
21748 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 PyObject *obj;
21750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21751 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21752 return SWIG_Py_Void();
21753 }
21754
21755 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21756 return SWIG_Python_InitShadowInstance(args);
21757 }
21758
21759 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21760 PyObject *resultobj = 0;
21761 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21762 wxString *arg2 = 0 ;
21763 wxConfigPathChanger *result = 0 ;
21764 void *argp1 = 0 ;
21765 int res1 = 0 ;
21766 bool temp2 = false ;
21767 PyObject * obj0 = 0 ;
21768 PyObject * obj1 = 0 ;
21769 char * kwnames[] = {
21770 (char *) "config",(char *) "entry", NULL
21771 };
21772
21773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21775 if (!SWIG_IsOK(res1)) {
21776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21777 }
21778 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21779 {
21780 arg2 = wxString_in_helper(obj1);
21781 if (arg2 == NULL) SWIG_fail;
21782 temp2 = true;
21783 }
21784 {
21785 PyThreadState* __tstate = wxPyBeginAllowThreads();
21786 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21787 wxPyEndAllowThreads(__tstate);
21788 if (PyErr_Occurred()) SWIG_fail;
21789 }
21790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21791 {
21792 if (temp2)
21793 delete arg2;
21794 }
21795 return resultobj;
21796 fail:
21797 {
21798 if (temp2)
21799 delete arg2;
21800 }
21801 return NULL;
21802 }
21803
21804
21805 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21806 PyObject *resultobj = 0;
21807 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21808 void *argp1 = 0 ;
21809 int res1 = 0 ;
21810 PyObject *swig_obj[1] ;
21811
21812 if (!args) SWIG_fail;
21813 swig_obj[0] = args;
21814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21815 if (!SWIG_IsOK(res1)) {
21816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21817 }
21818 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21819 {
21820 PyThreadState* __tstate = wxPyBeginAllowThreads();
21821 delete arg1;
21822
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 resultobj = SWIG_Py_Void();
21827 return resultobj;
21828 fail:
21829 return NULL;
21830 }
21831
21832
21833 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21834 PyObject *resultobj = 0;
21835 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21836 wxString *result = 0 ;
21837 void *argp1 = 0 ;
21838 int res1 = 0 ;
21839 PyObject *swig_obj[1] ;
21840
21841 if (!args) SWIG_fail;
21842 swig_obj[0] = args;
21843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21844 if (!SWIG_IsOK(res1)) {
21845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21846 }
21847 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21848 {
21849 PyThreadState* __tstate = wxPyBeginAllowThreads();
21850 {
21851 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21852 result = (wxString *) &_result_ref;
21853 }
21854 wxPyEndAllowThreads(__tstate);
21855 if (PyErr_Occurred()) SWIG_fail;
21856 }
21857 {
21858 #if wxUSE_UNICODE
21859 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21860 #else
21861 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21862 #endif
21863 }
21864 return resultobj;
21865 fail:
21866 return NULL;
21867 }
21868
21869
21870 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21871 PyObject *obj;
21872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21873 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21874 return SWIG_Py_Void();
21875 }
21876
21877 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21878 return SWIG_Python_InitShadowInstance(args);
21879 }
21880
21881 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj = 0;
21883 wxString *arg1 = 0 ;
21884 wxString result;
21885 bool temp1 = false ;
21886 PyObject * obj0 = 0 ;
21887 char * kwnames[] = {
21888 (char *) "sz", NULL
21889 };
21890
21891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21892 {
21893 arg1 = wxString_in_helper(obj0);
21894 if (arg1 == NULL) SWIG_fail;
21895 temp1 = true;
21896 }
21897 {
21898 PyThreadState* __tstate = wxPyBeginAllowThreads();
21899 result = wxExpandEnvVars((wxString const &)*arg1);
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 {
21904 #if wxUSE_UNICODE
21905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21906 #else
21907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21908 #endif
21909 }
21910 {
21911 if (temp1)
21912 delete arg1;
21913 }
21914 return resultobj;
21915 fail:
21916 {
21917 if (temp1)
21918 delete arg1;
21919 }
21920 return NULL;
21921 }
21922
21923
21924 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21925 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21926 return 1;
21927 }
21928
21929
21930 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21931 PyObject *pyobj = 0;
21932
21933 {
21934 #if wxUSE_UNICODE
21935 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21936 #else
21937 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21938 #endif
21939 }
21940 return pyobj;
21941 }
21942
21943
21944 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21945 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21946 return 1;
21947 }
21948
21949
21950 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21951 PyObject *pyobj = 0;
21952
21953 {
21954 #if wxUSE_UNICODE
21955 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21956 #else
21957 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21958 #endif
21959 }
21960 return pyobj;
21961 }
21962
21963
21964 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21965 PyObject *resultobj = 0;
21966 wxDateTime::Country arg1 ;
21967 int val1 ;
21968 int ecode1 = 0 ;
21969 PyObject * obj0 = 0 ;
21970 char * kwnames[] = {
21971 (char *) "country", NULL
21972 };
21973
21974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21975 ecode1 = SWIG_AsVal_int(obj0, &val1);
21976 if (!SWIG_IsOK(ecode1)) {
21977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21978 }
21979 arg1 = static_cast< wxDateTime::Country >(val1);
21980 {
21981 PyThreadState* __tstate = wxPyBeginAllowThreads();
21982 wxDateTime::SetCountry(arg1);
21983 wxPyEndAllowThreads(__tstate);
21984 if (PyErr_Occurred()) SWIG_fail;
21985 }
21986 resultobj = SWIG_Py_Void();
21987 return resultobj;
21988 fail:
21989 return NULL;
21990 }
21991
21992
21993 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21994 PyObject *resultobj = 0;
21995 wxDateTime::Country result;
21996
21997 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21998 {
21999 PyThreadState* __tstate = wxPyBeginAllowThreads();
22000 result = (wxDateTime::Country)wxDateTime::GetCountry();
22001 wxPyEndAllowThreads(__tstate);
22002 if (PyErr_Occurred()) SWIG_fail;
22003 }
22004 resultobj = SWIG_From_int(static_cast< int >(result));
22005 return resultobj;
22006 fail:
22007 return NULL;
22008 }
22009
22010
22011 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22012 PyObject *resultobj = 0;
22013 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22014 bool result;
22015 int val1 ;
22016 int ecode1 = 0 ;
22017 PyObject * obj0 = 0 ;
22018 char * kwnames[] = {
22019 (char *) "country", NULL
22020 };
22021
22022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22023 if (obj0) {
22024 ecode1 = SWIG_AsVal_int(obj0, &val1);
22025 if (!SWIG_IsOK(ecode1)) {
22026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22027 }
22028 arg1 = static_cast< wxDateTime::Country >(val1);
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 {
22037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22038 }
22039 return resultobj;
22040 fail:
22041 return NULL;
22042 }
22043
22044
22045 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22046 PyObject *resultobj = 0;
22047 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22048 int result;
22049 int val1 ;
22050 int ecode1 = 0 ;
22051 PyObject * obj0 = 0 ;
22052 char * kwnames[] = {
22053 (char *) "cal", NULL
22054 };
22055
22056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
22057 if (obj0) {
22058 ecode1 = SWIG_AsVal_int(obj0, &val1);
22059 if (!SWIG_IsOK(ecode1)) {
22060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22061 }
22062 arg1 = static_cast< wxDateTime::Calendar >(val1);
22063 }
22064 {
22065 PyThreadState* __tstate = wxPyBeginAllowThreads();
22066 result = (int)wxDateTime::GetCurrentYear(arg1);
22067 wxPyEndAllowThreads(__tstate);
22068 if (PyErr_Occurred()) SWIG_fail;
22069 }
22070 resultobj = SWIG_From_int(static_cast< int >(result));
22071 return resultobj;
22072 fail:
22073 return NULL;
22074 }
22075
22076
22077 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22078 PyObject *resultobj = 0;
22079 int arg1 ;
22080 int result;
22081 int val1 ;
22082 int ecode1 = 0 ;
22083 PyObject * obj0 = 0 ;
22084 char * kwnames[] = {
22085 (char *) "year", NULL
22086 };
22087
22088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
22089 ecode1 = SWIG_AsVal_int(obj0, &val1);
22090 if (!SWIG_IsOK(ecode1)) {
22091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
22092 }
22093 arg1 = static_cast< int >(val1);
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 result = (int)wxDateTime::ConvertYearToBC(arg1);
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 resultobj = SWIG_From_int(static_cast< int >(result));
22101 return resultobj;
22102 fail:
22103 return NULL;
22104 }
22105
22106
22107 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22108 PyObject *resultobj = 0;
22109 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22110 wxDateTime::Month result;
22111 int val1 ;
22112 int ecode1 = 0 ;
22113 PyObject * obj0 = 0 ;
22114 char * kwnames[] = {
22115 (char *) "cal", NULL
22116 };
22117
22118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22119 if (obj0) {
22120 ecode1 = SWIG_AsVal_int(obj0, &val1);
22121 if (!SWIG_IsOK(ecode1)) {
22122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22123 }
22124 arg1 = static_cast< wxDateTime::Calendar >(val1);
22125 }
22126 {
22127 PyThreadState* __tstate = wxPyBeginAllowThreads();
22128 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22129 wxPyEndAllowThreads(__tstate);
22130 if (PyErr_Occurred()) SWIG_fail;
22131 }
22132 resultobj = SWIG_From_int(static_cast< int >(result));
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj = 0;
22141 int arg1 = (int) wxDateTime::Inv_Year ;
22142 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22143 bool result;
22144 int val1 ;
22145 int ecode1 = 0 ;
22146 int val2 ;
22147 int ecode2 = 0 ;
22148 PyObject * obj0 = 0 ;
22149 PyObject * obj1 = 0 ;
22150 char * kwnames[] = {
22151 (char *) "year",(char *) "cal", NULL
22152 };
22153
22154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22155 if (obj0) {
22156 ecode1 = SWIG_AsVal_int(obj0, &val1);
22157 if (!SWIG_IsOK(ecode1)) {
22158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22159 }
22160 arg1 = static_cast< int >(val1);
22161 }
22162 if (obj1) {
22163 ecode2 = SWIG_AsVal_int(obj1, &val2);
22164 if (!SWIG_IsOK(ecode2)) {
22165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22166 }
22167 arg2 = static_cast< wxDateTime::Calendar >(val2);
22168 }
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 {
22176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22177 }
22178 return resultobj;
22179 fail:
22180 return NULL;
22181 }
22182
22183
22184 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22185 PyObject *resultobj = 0;
22186 int arg1 = (int) wxDateTime::Inv_Year ;
22187 int result;
22188 int val1 ;
22189 int ecode1 = 0 ;
22190 PyObject * obj0 = 0 ;
22191 char * kwnames[] = {
22192 (char *) "year", NULL
22193 };
22194
22195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22196 if (obj0) {
22197 ecode1 = SWIG_AsVal_int(obj0, &val1);
22198 if (!SWIG_IsOK(ecode1)) {
22199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22200 }
22201 arg1 = static_cast< int >(val1);
22202 }
22203 {
22204 PyThreadState* __tstate = wxPyBeginAllowThreads();
22205 result = (int)wxDateTime::GetCentury(arg1);
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 resultobj = SWIG_From_int(static_cast< int >(result));
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj = 0;
22218 int arg1 ;
22219 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22220 int result;
22221 int val1 ;
22222 int ecode1 = 0 ;
22223 int val2 ;
22224 int ecode2 = 0 ;
22225 PyObject * obj0 = 0 ;
22226 PyObject * obj1 = 0 ;
22227 char * kwnames[] = {
22228 (char *) "year",(char *) "cal", NULL
22229 };
22230
22231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22232 ecode1 = SWIG_AsVal_int(obj0, &val1);
22233 if (!SWIG_IsOK(ecode1)) {
22234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22235 }
22236 arg1 = static_cast< int >(val1);
22237 if (obj1) {
22238 ecode2 = SWIG_AsVal_int(obj1, &val2);
22239 if (!SWIG_IsOK(ecode2)) {
22240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22241 }
22242 arg2 = static_cast< wxDateTime::Calendar >(val2);
22243 }
22244 {
22245 PyThreadState* __tstate = wxPyBeginAllowThreads();
22246 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22247 wxPyEndAllowThreads(__tstate);
22248 if (PyErr_Occurred()) SWIG_fail;
22249 }
22250 resultobj = SWIG_From_int(static_cast< int >(result));
22251 return resultobj;
22252 fail:
22253 return NULL;
22254 }
22255
22256
22257 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22258 PyObject *resultobj = 0;
22259 wxDateTime::Month arg1 ;
22260 int arg2 = (int) wxDateTime::Inv_Year ;
22261 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22262 int result;
22263 int val1 ;
22264 int ecode1 = 0 ;
22265 int val2 ;
22266 int ecode2 = 0 ;
22267 int val3 ;
22268 int ecode3 = 0 ;
22269 PyObject * obj0 = 0 ;
22270 PyObject * obj1 = 0 ;
22271 PyObject * obj2 = 0 ;
22272 char * kwnames[] = {
22273 (char *) "month",(char *) "year",(char *) "cal", NULL
22274 };
22275
22276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22277 ecode1 = SWIG_AsVal_int(obj0, &val1);
22278 if (!SWIG_IsOK(ecode1)) {
22279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22280 }
22281 arg1 = static_cast< wxDateTime::Month >(val1);
22282 if (obj1) {
22283 ecode2 = SWIG_AsVal_int(obj1, &val2);
22284 if (!SWIG_IsOK(ecode2)) {
22285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22286 }
22287 arg2 = static_cast< int >(val2);
22288 }
22289 if (obj2) {
22290 ecode3 = SWIG_AsVal_int(obj2, &val3);
22291 if (!SWIG_IsOK(ecode3)) {
22292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22293 }
22294 arg3 = static_cast< wxDateTime::Calendar >(val3);
22295 }
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22299 wxPyEndAllowThreads(__tstate);
22300 if (PyErr_Occurred()) SWIG_fail;
22301 }
22302 resultobj = SWIG_From_int(static_cast< int >(result));
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22310 PyObject *resultobj = 0;
22311 wxDateTime::Month arg1 ;
22312 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22313 wxString result;
22314 int val1 ;
22315 int ecode1 = 0 ;
22316 int val2 ;
22317 int ecode2 = 0 ;
22318 PyObject * obj0 = 0 ;
22319 PyObject * obj1 = 0 ;
22320 char * kwnames[] = {
22321 (char *) "month",(char *) "flags", NULL
22322 };
22323
22324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22325 ecode1 = SWIG_AsVal_int(obj0, &val1);
22326 if (!SWIG_IsOK(ecode1)) {
22327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22328 }
22329 arg1 = static_cast< wxDateTime::Month >(val1);
22330 if (obj1) {
22331 ecode2 = SWIG_AsVal_int(obj1, &val2);
22332 if (!SWIG_IsOK(ecode2)) {
22333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22334 }
22335 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22336 }
22337 {
22338 PyThreadState* __tstate = wxPyBeginAllowThreads();
22339 result = wxDateTime::GetMonthName(arg1,arg2);
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 {
22344 #if wxUSE_UNICODE
22345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22346 #else
22347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22348 #endif
22349 }
22350 return resultobj;
22351 fail:
22352 return NULL;
22353 }
22354
22355
22356 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22357 PyObject *resultobj = 0;
22358 wxDateTime::WeekDay arg1 ;
22359 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22360 wxString result;
22361 int val1 ;
22362 int ecode1 = 0 ;
22363 int val2 ;
22364 int ecode2 = 0 ;
22365 PyObject * obj0 = 0 ;
22366 PyObject * obj1 = 0 ;
22367 char * kwnames[] = {
22368 (char *) "weekday",(char *) "flags", NULL
22369 };
22370
22371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22372 ecode1 = SWIG_AsVal_int(obj0, &val1);
22373 if (!SWIG_IsOK(ecode1)) {
22374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22375 }
22376 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22377 if (obj1) {
22378 ecode2 = SWIG_AsVal_int(obj1, &val2);
22379 if (!SWIG_IsOK(ecode2)) {
22380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22381 }
22382 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22383 }
22384 {
22385 PyThreadState* __tstate = wxPyBeginAllowThreads();
22386 result = wxDateTime::GetWeekDayName(arg1,arg2);
22387 wxPyEndAllowThreads(__tstate);
22388 if (PyErr_Occurred()) SWIG_fail;
22389 }
22390 {
22391 #if wxUSE_UNICODE
22392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22393 #else
22394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22395 #endif
22396 }
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 PyObject *result = 0 ;
22406
22407 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 result = (PyObject *)wxDateTime_GetAmPmStrings();
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 resultobj = result;
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22422 PyObject *resultobj = 0;
22423 int arg1 = (int) wxDateTime::Inv_Year ;
22424 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22425 bool result;
22426 int val1 ;
22427 int ecode1 = 0 ;
22428 int val2 ;
22429 int ecode2 = 0 ;
22430 PyObject * obj0 = 0 ;
22431 PyObject * obj1 = 0 ;
22432 char * kwnames[] = {
22433 (char *) "year",(char *) "country", NULL
22434 };
22435
22436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22437 if (obj0) {
22438 ecode1 = SWIG_AsVal_int(obj0, &val1);
22439 if (!SWIG_IsOK(ecode1)) {
22440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22441 }
22442 arg1 = static_cast< int >(val1);
22443 }
22444 if (obj1) {
22445 ecode2 = SWIG_AsVal_int(obj1, &val2);
22446 if (!SWIG_IsOK(ecode2)) {
22447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22448 }
22449 arg2 = static_cast< wxDateTime::Country >(val2);
22450 }
22451 {
22452 PyThreadState* __tstate = wxPyBeginAllowThreads();
22453 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22454 wxPyEndAllowThreads(__tstate);
22455 if (PyErr_Occurred()) SWIG_fail;
22456 }
22457 {
22458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22459 }
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22467 PyObject *resultobj = 0;
22468 int arg1 = (int) wxDateTime::Inv_Year ;
22469 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22470 wxDateTime result;
22471 int val1 ;
22472 int ecode1 = 0 ;
22473 int val2 ;
22474 int ecode2 = 0 ;
22475 PyObject * obj0 = 0 ;
22476 PyObject * obj1 = 0 ;
22477 char * kwnames[] = {
22478 (char *) "year",(char *) "country", NULL
22479 };
22480
22481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22482 if (obj0) {
22483 ecode1 = SWIG_AsVal_int(obj0, &val1);
22484 if (!SWIG_IsOK(ecode1)) {
22485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22486 }
22487 arg1 = static_cast< int >(val1);
22488 }
22489 if (obj1) {
22490 ecode2 = SWIG_AsVal_int(obj1, &val2);
22491 if (!SWIG_IsOK(ecode2)) {
22492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22493 }
22494 arg2 = static_cast< wxDateTime::Country >(val2);
22495 }
22496 {
22497 PyThreadState* __tstate = wxPyBeginAllowThreads();
22498 result = wxDateTime::GetBeginDST(arg1,arg2);
22499 wxPyEndAllowThreads(__tstate);
22500 if (PyErr_Occurred()) SWIG_fail;
22501 }
22502 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22510 PyObject *resultobj = 0;
22511 int arg1 = (int) wxDateTime::Inv_Year ;
22512 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22513 wxDateTime result;
22514 int val1 ;
22515 int ecode1 = 0 ;
22516 int val2 ;
22517 int ecode2 = 0 ;
22518 PyObject * obj0 = 0 ;
22519 PyObject * obj1 = 0 ;
22520 char * kwnames[] = {
22521 (char *) "year",(char *) "country", NULL
22522 };
22523
22524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22525 if (obj0) {
22526 ecode1 = SWIG_AsVal_int(obj0, &val1);
22527 if (!SWIG_IsOK(ecode1)) {
22528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22529 }
22530 arg1 = static_cast< int >(val1);
22531 }
22532 if (obj1) {
22533 ecode2 = SWIG_AsVal_int(obj1, &val2);
22534 if (!SWIG_IsOK(ecode2)) {
22535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22536 }
22537 arg2 = static_cast< wxDateTime::Country >(val2);
22538 }
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 result = wxDateTime::GetEndDST(arg1,arg2);
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22553 PyObject *resultobj = 0;
22554 wxDateTime result;
22555
22556 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22557 {
22558 PyThreadState* __tstate = wxPyBeginAllowThreads();
22559 result = wxDateTime::Now();
22560 wxPyEndAllowThreads(__tstate);
22561 if (PyErr_Occurred()) SWIG_fail;
22562 }
22563 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22571 PyObject *resultobj = 0;
22572 wxDateTime result;
22573
22574 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22575 {
22576 PyThreadState* __tstate = wxPyBeginAllowThreads();
22577 result = wxDateTime::UNow();
22578 wxPyEndAllowThreads(__tstate);
22579 if (PyErr_Occurred()) SWIG_fail;
22580 }
22581 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22582 return resultobj;
22583 fail:
22584 return NULL;
22585 }
22586
22587
22588 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22589 PyObject *resultobj = 0;
22590 wxDateTime result;
22591
22592 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22593 {
22594 PyThreadState* __tstate = wxPyBeginAllowThreads();
22595 result = wxDateTime::Today();
22596 wxPyEndAllowThreads(__tstate);
22597 if (PyErr_Occurred()) SWIG_fail;
22598 }
22599 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22600 return resultobj;
22601 fail:
22602 return NULL;
22603 }
22604
22605
22606 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22607 PyObject *resultobj = 0;
22608 wxDateTime *result = 0 ;
22609
22610 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22611 {
22612 PyThreadState* __tstate = wxPyBeginAllowThreads();
22613 result = (wxDateTime *)new wxDateTime();
22614 wxPyEndAllowThreads(__tstate);
22615 if (PyErr_Occurred()) SWIG_fail;
22616 }
22617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22625 PyObject *resultobj = 0;
22626 time_t arg1 ;
22627 wxDateTime *result = 0 ;
22628 unsigned int val1 ;
22629 int ecode1 = 0 ;
22630 PyObject * obj0 = 0 ;
22631 char * kwnames[] = {
22632 (char *) "timet", NULL
22633 };
22634
22635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22636 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22637 if (!SWIG_IsOK(ecode1)) {
22638 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22639 }
22640 arg1 = static_cast< time_t >(val1);
22641 {
22642 PyThreadState* __tstate = wxPyBeginAllowThreads();
22643 result = (wxDateTime *)new wxDateTime(arg1);
22644 wxPyEndAllowThreads(__tstate);
22645 if (PyErr_Occurred()) SWIG_fail;
22646 }
22647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22655 PyObject *resultobj = 0;
22656 double arg1 ;
22657 wxDateTime *result = 0 ;
22658 double val1 ;
22659 int ecode1 = 0 ;
22660 PyObject * obj0 = 0 ;
22661 char * kwnames[] = {
22662 (char *) "jdn", NULL
22663 };
22664
22665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22666 ecode1 = SWIG_AsVal_double(obj0, &val1);
22667 if (!SWIG_IsOK(ecode1)) {
22668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22669 }
22670 arg1 = static_cast< double >(val1);
22671 {
22672 PyThreadState* __tstate = wxPyBeginAllowThreads();
22673 result = (wxDateTime *)new wxDateTime(arg1);
22674 wxPyEndAllowThreads(__tstate);
22675 if (PyErr_Occurred()) SWIG_fail;
22676 }
22677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22685 PyObject *resultobj = 0;
22686 int arg1 ;
22687 int arg2 = (int) 0 ;
22688 int arg3 = (int) 0 ;
22689 int arg4 = (int) 0 ;
22690 wxDateTime *result = 0 ;
22691 int val1 ;
22692 int ecode1 = 0 ;
22693 int val2 ;
22694 int ecode2 = 0 ;
22695 int val3 ;
22696 int ecode3 = 0 ;
22697 int val4 ;
22698 int ecode4 = 0 ;
22699 PyObject * obj0 = 0 ;
22700 PyObject * obj1 = 0 ;
22701 PyObject * obj2 = 0 ;
22702 PyObject * obj3 = 0 ;
22703 char * kwnames[] = {
22704 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22705 };
22706
22707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22708 ecode1 = SWIG_AsVal_int(obj0, &val1);
22709 if (!SWIG_IsOK(ecode1)) {
22710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22711 }
22712 arg1 = static_cast< int >(val1);
22713 if (obj1) {
22714 ecode2 = SWIG_AsVal_int(obj1, &val2);
22715 if (!SWIG_IsOK(ecode2)) {
22716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22717 }
22718 arg2 = static_cast< int >(val2);
22719 }
22720 if (obj2) {
22721 ecode3 = SWIG_AsVal_int(obj2, &val3);
22722 if (!SWIG_IsOK(ecode3)) {
22723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22724 }
22725 arg3 = static_cast< int >(val3);
22726 }
22727 if (obj3) {
22728 ecode4 = SWIG_AsVal_int(obj3, &val4);
22729 if (!SWIG_IsOK(ecode4)) {
22730 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22731 }
22732 arg4 = static_cast< int >(val4);
22733 }
22734 {
22735 PyThreadState* __tstate = wxPyBeginAllowThreads();
22736 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22737 wxPyEndAllowThreads(__tstate);
22738 if (PyErr_Occurred()) SWIG_fail;
22739 }
22740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22741 return resultobj;
22742 fail:
22743 return NULL;
22744 }
22745
22746
22747 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22748 PyObject *resultobj = 0;
22749 int arg1 ;
22750 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22751 int arg3 = (int) wxDateTime::Inv_Year ;
22752 int arg4 = (int) 0 ;
22753 int arg5 = (int) 0 ;
22754 int arg6 = (int) 0 ;
22755 int arg7 = (int) 0 ;
22756 wxDateTime *result = 0 ;
22757 int val1 ;
22758 int ecode1 = 0 ;
22759 int val2 ;
22760 int ecode2 = 0 ;
22761 int val3 ;
22762 int ecode3 = 0 ;
22763 int val4 ;
22764 int ecode4 = 0 ;
22765 int val5 ;
22766 int ecode5 = 0 ;
22767 int val6 ;
22768 int ecode6 = 0 ;
22769 int val7 ;
22770 int ecode7 = 0 ;
22771 PyObject * obj0 = 0 ;
22772 PyObject * obj1 = 0 ;
22773 PyObject * obj2 = 0 ;
22774 PyObject * obj3 = 0 ;
22775 PyObject * obj4 = 0 ;
22776 PyObject * obj5 = 0 ;
22777 PyObject * obj6 = 0 ;
22778 char * kwnames[] = {
22779 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22780 };
22781
22782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22783 ecode1 = SWIG_AsVal_int(obj0, &val1);
22784 if (!SWIG_IsOK(ecode1)) {
22785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22786 }
22787 arg1 = static_cast< int >(val1);
22788 if (obj1) {
22789 ecode2 = SWIG_AsVal_int(obj1, &val2);
22790 if (!SWIG_IsOK(ecode2)) {
22791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22792 }
22793 arg2 = static_cast< wxDateTime::Month >(val2);
22794 }
22795 if (obj2) {
22796 ecode3 = SWIG_AsVal_int(obj2, &val3);
22797 if (!SWIG_IsOK(ecode3)) {
22798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22799 }
22800 arg3 = static_cast< int >(val3);
22801 }
22802 if (obj3) {
22803 ecode4 = SWIG_AsVal_int(obj3, &val4);
22804 if (!SWIG_IsOK(ecode4)) {
22805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22806 }
22807 arg4 = static_cast< int >(val4);
22808 }
22809 if (obj4) {
22810 ecode5 = SWIG_AsVal_int(obj4, &val5);
22811 if (!SWIG_IsOK(ecode5)) {
22812 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22813 }
22814 arg5 = static_cast< int >(val5);
22815 }
22816 if (obj5) {
22817 ecode6 = SWIG_AsVal_int(obj5, &val6);
22818 if (!SWIG_IsOK(ecode6)) {
22819 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22820 }
22821 arg6 = static_cast< int >(val6);
22822 }
22823 if (obj6) {
22824 ecode7 = SWIG_AsVal_int(obj6, &val7);
22825 if (!SWIG_IsOK(ecode7)) {
22826 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22827 }
22828 arg7 = static_cast< int >(val7);
22829 }
22830 {
22831 PyThreadState* __tstate = wxPyBeginAllowThreads();
22832 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22833 wxPyEndAllowThreads(__tstate);
22834 if (PyErr_Occurred()) SWIG_fail;
22835 }
22836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22837 return resultobj;
22838 fail:
22839 return NULL;
22840 }
22841
22842
22843 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22844 PyObject *resultobj = 0;
22845 wxDateTime *arg1 = 0 ;
22846 wxDateTime *result = 0 ;
22847 void *argp1 = 0 ;
22848 int res1 = 0 ;
22849 PyObject * obj0 = 0 ;
22850 char * kwnames[] = {
22851 (char *) "date", NULL
22852 };
22853
22854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22855 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22858 }
22859 if (!argp1) {
22860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22861 }
22862 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22863 {
22864 PyThreadState* __tstate = wxPyBeginAllowThreads();
22865 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22866 wxPyEndAllowThreads(__tstate);
22867 if (PyErr_Occurred()) SWIG_fail;
22868 }
22869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22870 return resultobj;
22871 fail:
22872 return NULL;
22873 }
22874
22875
22876 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22877 PyObject *resultobj = 0;
22878 wxDateTime *arg1 = (wxDateTime *) 0 ;
22879 void *argp1 = 0 ;
22880 int res1 = 0 ;
22881 PyObject *swig_obj[1] ;
22882
22883 if (!args) SWIG_fail;
22884 swig_obj[0] = args;
22885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22886 if (!SWIG_IsOK(res1)) {
22887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22888 }
22889 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22890 {
22891 PyThreadState* __tstate = wxPyBeginAllowThreads();
22892 delete arg1;
22893
22894 wxPyEndAllowThreads(__tstate);
22895 if (PyErr_Occurred()) SWIG_fail;
22896 }
22897 resultobj = SWIG_Py_Void();
22898 return resultobj;
22899 fail:
22900 return NULL;
22901 }
22902
22903
22904 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22905 PyObject *resultobj = 0;
22906 wxDateTime *arg1 = (wxDateTime *) 0 ;
22907 wxDateTime *result = 0 ;
22908 void *argp1 = 0 ;
22909 int res1 = 0 ;
22910 PyObject *swig_obj[1] ;
22911
22912 if (!args) SWIG_fail;
22913 swig_obj[0] = args;
22914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22915 if (!SWIG_IsOK(res1)) {
22916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22917 }
22918 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 {
22922 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22923 result = (wxDateTime *) &_result_ref;
22924 }
22925 wxPyEndAllowThreads(__tstate);
22926 if (PyErr_Occurred()) SWIG_fail;
22927 }
22928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22929 return resultobj;
22930 fail:
22931 return NULL;
22932 }
22933
22934
22935 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22936 PyObject *resultobj = 0;
22937 wxDateTime *arg1 = (wxDateTime *) 0 ;
22938 time_t arg2 ;
22939 wxDateTime *result = 0 ;
22940 void *argp1 = 0 ;
22941 int res1 = 0 ;
22942 unsigned int val2 ;
22943 int ecode2 = 0 ;
22944 PyObject * obj0 = 0 ;
22945 PyObject * obj1 = 0 ;
22946 char * kwnames[] = {
22947 (char *) "self",(char *) "timet", NULL
22948 };
22949
22950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22952 if (!SWIG_IsOK(res1)) {
22953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22954 }
22955 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22956 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22957 if (!SWIG_IsOK(ecode2)) {
22958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22959 }
22960 arg2 = static_cast< time_t >(val2);
22961 {
22962 PyThreadState* __tstate = wxPyBeginAllowThreads();
22963 {
22964 wxDateTime &_result_ref = (arg1)->Set(arg2);
22965 result = (wxDateTime *) &_result_ref;
22966 }
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22971 return resultobj;
22972 fail:
22973 return NULL;
22974 }
22975
22976
22977 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22978 PyObject *resultobj = 0;
22979 wxDateTime *arg1 = (wxDateTime *) 0 ;
22980 double arg2 ;
22981 wxDateTime *result = 0 ;
22982 void *argp1 = 0 ;
22983 int res1 = 0 ;
22984 double val2 ;
22985 int ecode2 = 0 ;
22986 PyObject * obj0 = 0 ;
22987 PyObject * obj1 = 0 ;
22988 char * kwnames[] = {
22989 (char *) "self",(char *) "jdn", NULL
22990 };
22991
22992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22994 if (!SWIG_IsOK(res1)) {
22995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22996 }
22997 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22998 ecode2 = SWIG_AsVal_double(obj1, &val2);
22999 if (!SWIG_IsOK(ecode2)) {
23000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23001 }
23002 arg2 = static_cast< double >(val2);
23003 {
23004 PyThreadState* __tstate = wxPyBeginAllowThreads();
23005 {
23006 wxDateTime &_result_ref = (arg1)->Set(arg2);
23007 result = (wxDateTime *) &_result_ref;
23008 }
23009 wxPyEndAllowThreads(__tstate);
23010 if (PyErr_Occurred()) SWIG_fail;
23011 }
23012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23013 return resultobj;
23014 fail:
23015 return NULL;
23016 }
23017
23018
23019 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23020 PyObject *resultobj = 0;
23021 wxDateTime *arg1 = (wxDateTime *) 0 ;
23022 int arg2 ;
23023 int arg3 = (int) 0 ;
23024 int arg4 = (int) 0 ;
23025 int arg5 = (int) 0 ;
23026 wxDateTime *result = 0 ;
23027 void *argp1 = 0 ;
23028 int res1 = 0 ;
23029 int val2 ;
23030 int ecode2 = 0 ;
23031 int val3 ;
23032 int ecode3 = 0 ;
23033 int val4 ;
23034 int ecode4 = 0 ;
23035 int val5 ;
23036 int ecode5 = 0 ;
23037 PyObject * obj0 = 0 ;
23038 PyObject * obj1 = 0 ;
23039 PyObject * obj2 = 0 ;
23040 PyObject * obj3 = 0 ;
23041 PyObject * obj4 = 0 ;
23042 char * kwnames[] = {
23043 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23044 };
23045
23046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23048 if (!SWIG_IsOK(res1)) {
23049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
23050 }
23051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23052 ecode2 = SWIG_AsVal_int(obj1, &val2);
23053 if (!SWIG_IsOK(ecode2)) {
23054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
23055 }
23056 arg2 = static_cast< int >(val2);
23057 if (obj2) {
23058 ecode3 = SWIG_AsVal_int(obj2, &val3);
23059 if (!SWIG_IsOK(ecode3)) {
23060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
23061 }
23062 arg3 = static_cast< int >(val3);
23063 }
23064 if (obj3) {
23065 ecode4 = SWIG_AsVal_int(obj3, &val4);
23066 if (!SWIG_IsOK(ecode4)) {
23067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
23068 }
23069 arg4 = static_cast< int >(val4);
23070 }
23071 if (obj4) {
23072 ecode5 = SWIG_AsVal_int(obj4, &val5);
23073 if (!SWIG_IsOK(ecode5)) {
23074 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
23075 }
23076 arg5 = static_cast< int >(val5);
23077 }
23078 {
23079 PyThreadState* __tstate = wxPyBeginAllowThreads();
23080 {
23081 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
23082 result = (wxDateTime *) &_result_ref;
23083 }
23084 wxPyEndAllowThreads(__tstate);
23085 if (PyErr_Occurred()) SWIG_fail;
23086 }
23087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23095 PyObject *resultobj = 0;
23096 wxDateTime *arg1 = (wxDateTime *) 0 ;
23097 int arg2 ;
23098 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23099 int arg4 = (int) wxDateTime::Inv_Year ;
23100 int arg5 = (int) 0 ;
23101 int arg6 = (int) 0 ;
23102 int arg7 = (int) 0 ;
23103 int arg8 = (int) 0 ;
23104 wxDateTime *result = 0 ;
23105 void *argp1 = 0 ;
23106 int res1 = 0 ;
23107 int val2 ;
23108 int ecode2 = 0 ;
23109 int val3 ;
23110 int ecode3 = 0 ;
23111 int val4 ;
23112 int ecode4 = 0 ;
23113 int val5 ;
23114 int ecode5 = 0 ;
23115 int val6 ;
23116 int ecode6 = 0 ;
23117 int val7 ;
23118 int ecode7 = 0 ;
23119 int val8 ;
23120 int ecode8 = 0 ;
23121 PyObject * obj0 = 0 ;
23122 PyObject * obj1 = 0 ;
23123 PyObject * obj2 = 0 ;
23124 PyObject * obj3 = 0 ;
23125 PyObject * obj4 = 0 ;
23126 PyObject * obj5 = 0 ;
23127 PyObject * obj6 = 0 ;
23128 PyObject * obj7 = 0 ;
23129 char * kwnames[] = {
23130 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23131 };
23132
23133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23135 if (!SWIG_IsOK(res1)) {
23136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23137 }
23138 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23139 ecode2 = SWIG_AsVal_int(obj1, &val2);
23140 if (!SWIG_IsOK(ecode2)) {
23141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23142 }
23143 arg2 = static_cast< int >(val2);
23144 if (obj2) {
23145 ecode3 = SWIG_AsVal_int(obj2, &val3);
23146 if (!SWIG_IsOK(ecode3)) {
23147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23148 }
23149 arg3 = static_cast< wxDateTime::Month >(val3);
23150 }
23151 if (obj3) {
23152 ecode4 = SWIG_AsVal_int(obj3, &val4);
23153 if (!SWIG_IsOK(ecode4)) {
23154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23155 }
23156 arg4 = static_cast< int >(val4);
23157 }
23158 if (obj4) {
23159 ecode5 = SWIG_AsVal_int(obj4, &val5);
23160 if (!SWIG_IsOK(ecode5)) {
23161 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23162 }
23163 arg5 = static_cast< int >(val5);
23164 }
23165 if (obj5) {
23166 ecode6 = SWIG_AsVal_int(obj5, &val6);
23167 if (!SWIG_IsOK(ecode6)) {
23168 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23169 }
23170 arg6 = static_cast< int >(val6);
23171 }
23172 if (obj6) {
23173 ecode7 = SWIG_AsVal_int(obj6, &val7);
23174 if (!SWIG_IsOK(ecode7)) {
23175 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23176 }
23177 arg7 = static_cast< int >(val7);
23178 }
23179 if (obj7) {
23180 ecode8 = SWIG_AsVal_int(obj7, &val8);
23181 if (!SWIG_IsOK(ecode8)) {
23182 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23183 }
23184 arg8 = static_cast< int >(val8);
23185 }
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 {
23189 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23190 result = (wxDateTime *) &_result_ref;
23191 }
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23203 PyObject *resultobj = 0;
23204 wxDateTime *arg1 = (wxDateTime *) 0 ;
23205 wxDateTime *result = 0 ;
23206 void *argp1 = 0 ;
23207 int res1 = 0 ;
23208 PyObject *swig_obj[1] ;
23209
23210 if (!args) SWIG_fail;
23211 swig_obj[0] = args;
23212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23213 if (!SWIG_IsOK(res1)) {
23214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23215 }
23216 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 {
23220 wxDateTime &_result_ref = (arg1)->ResetTime();
23221 result = (wxDateTime *) &_result_ref;
23222 }
23223 wxPyEndAllowThreads(__tstate);
23224 if (PyErr_Occurred()) SWIG_fail;
23225 }
23226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23227 return resultobj;
23228 fail:
23229 return NULL;
23230 }
23231
23232
23233 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23234 PyObject *resultobj = 0;
23235 wxDateTime *arg1 = (wxDateTime *) 0 ;
23236 int arg2 ;
23237 wxDateTime *result = 0 ;
23238 void *argp1 = 0 ;
23239 int res1 = 0 ;
23240 int val2 ;
23241 int ecode2 = 0 ;
23242 PyObject * obj0 = 0 ;
23243 PyObject * obj1 = 0 ;
23244 char * kwnames[] = {
23245 (char *) "self",(char *) "year", NULL
23246 };
23247
23248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23250 if (!SWIG_IsOK(res1)) {
23251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23252 }
23253 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23254 ecode2 = SWIG_AsVal_int(obj1, &val2);
23255 if (!SWIG_IsOK(ecode2)) {
23256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23257 }
23258 arg2 = static_cast< int >(val2);
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 {
23262 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23263 result = (wxDateTime *) &_result_ref;
23264 }
23265 wxPyEndAllowThreads(__tstate);
23266 if (PyErr_Occurred()) SWIG_fail;
23267 }
23268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23269 return resultobj;
23270 fail:
23271 return NULL;
23272 }
23273
23274
23275 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23276 PyObject *resultobj = 0;
23277 wxDateTime *arg1 = (wxDateTime *) 0 ;
23278 wxDateTime::Month arg2 ;
23279 wxDateTime *result = 0 ;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 int val2 ;
23283 int ecode2 = 0 ;
23284 PyObject * obj0 = 0 ;
23285 PyObject * obj1 = 0 ;
23286 char * kwnames[] = {
23287 (char *) "self",(char *) "month", NULL
23288 };
23289
23290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23292 if (!SWIG_IsOK(res1)) {
23293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23294 }
23295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23296 ecode2 = SWIG_AsVal_int(obj1, &val2);
23297 if (!SWIG_IsOK(ecode2)) {
23298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23299 }
23300 arg2 = static_cast< wxDateTime::Month >(val2);
23301 {
23302 PyThreadState* __tstate = wxPyBeginAllowThreads();
23303 {
23304 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23305 result = (wxDateTime *) &_result_ref;
23306 }
23307 wxPyEndAllowThreads(__tstate);
23308 if (PyErr_Occurred()) SWIG_fail;
23309 }
23310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23311 return resultobj;
23312 fail:
23313 return NULL;
23314 }
23315
23316
23317 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23318 PyObject *resultobj = 0;
23319 wxDateTime *arg1 = (wxDateTime *) 0 ;
23320 int arg2 ;
23321 wxDateTime *result = 0 ;
23322 void *argp1 = 0 ;
23323 int res1 = 0 ;
23324 int val2 ;
23325 int ecode2 = 0 ;
23326 PyObject * obj0 = 0 ;
23327 PyObject * obj1 = 0 ;
23328 char * kwnames[] = {
23329 (char *) "self",(char *) "day", NULL
23330 };
23331
23332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23334 if (!SWIG_IsOK(res1)) {
23335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23336 }
23337 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23338 ecode2 = SWIG_AsVal_int(obj1, &val2);
23339 if (!SWIG_IsOK(ecode2)) {
23340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23341 }
23342 arg2 = static_cast< int >(val2);
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 {
23346 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23347 result = (wxDateTime *) &_result_ref;
23348 }
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj = 0;
23361 wxDateTime *arg1 = (wxDateTime *) 0 ;
23362 int arg2 ;
23363 wxDateTime *result = 0 ;
23364 void *argp1 = 0 ;
23365 int res1 = 0 ;
23366 int val2 ;
23367 int ecode2 = 0 ;
23368 PyObject * obj0 = 0 ;
23369 PyObject * obj1 = 0 ;
23370 char * kwnames[] = {
23371 (char *) "self",(char *) "hour", NULL
23372 };
23373
23374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23376 if (!SWIG_IsOK(res1)) {
23377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23378 }
23379 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23380 ecode2 = SWIG_AsVal_int(obj1, &val2);
23381 if (!SWIG_IsOK(ecode2)) {
23382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23383 }
23384 arg2 = static_cast< int >(val2);
23385 {
23386 PyThreadState* __tstate = wxPyBeginAllowThreads();
23387 {
23388 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23389 result = (wxDateTime *) &_result_ref;
23390 }
23391 wxPyEndAllowThreads(__tstate);
23392 if (PyErr_Occurred()) SWIG_fail;
23393 }
23394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23395 return resultobj;
23396 fail:
23397 return NULL;
23398 }
23399
23400
23401 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23402 PyObject *resultobj = 0;
23403 wxDateTime *arg1 = (wxDateTime *) 0 ;
23404 int arg2 ;
23405 wxDateTime *result = 0 ;
23406 void *argp1 = 0 ;
23407 int res1 = 0 ;
23408 int val2 ;
23409 int ecode2 = 0 ;
23410 PyObject * obj0 = 0 ;
23411 PyObject * obj1 = 0 ;
23412 char * kwnames[] = {
23413 (char *) "self",(char *) "minute", NULL
23414 };
23415
23416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23418 if (!SWIG_IsOK(res1)) {
23419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23420 }
23421 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23422 ecode2 = SWIG_AsVal_int(obj1, &val2);
23423 if (!SWIG_IsOK(ecode2)) {
23424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23425 }
23426 arg2 = static_cast< int >(val2);
23427 {
23428 PyThreadState* __tstate = wxPyBeginAllowThreads();
23429 {
23430 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23431 result = (wxDateTime *) &_result_ref;
23432 }
23433 wxPyEndAllowThreads(__tstate);
23434 if (PyErr_Occurred()) SWIG_fail;
23435 }
23436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23437 return resultobj;
23438 fail:
23439 return NULL;
23440 }
23441
23442
23443 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23444 PyObject *resultobj = 0;
23445 wxDateTime *arg1 = (wxDateTime *) 0 ;
23446 int arg2 ;
23447 wxDateTime *result = 0 ;
23448 void *argp1 = 0 ;
23449 int res1 = 0 ;
23450 int val2 ;
23451 int ecode2 = 0 ;
23452 PyObject * obj0 = 0 ;
23453 PyObject * obj1 = 0 ;
23454 char * kwnames[] = {
23455 (char *) "self",(char *) "second", NULL
23456 };
23457
23458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23460 if (!SWIG_IsOK(res1)) {
23461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23462 }
23463 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23464 ecode2 = SWIG_AsVal_int(obj1, &val2);
23465 if (!SWIG_IsOK(ecode2)) {
23466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23467 }
23468 arg2 = static_cast< int >(val2);
23469 {
23470 PyThreadState* __tstate = wxPyBeginAllowThreads();
23471 {
23472 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23473 result = (wxDateTime *) &_result_ref;
23474 }
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj = 0;
23487 wxDateTime *arg1 = (wxDateTime *) 0 ;
23488 int arg2 ;
23489 wxDateTime *result = 0 ;
23490 void *argp1 = 0 ;
23491 int res1 = 0 ;
23492 int val2 ;
23493 int ecode2 = 0 ;
23494 PyObject * obj0 = 0 ;
23495 PyObject * obj1 = 0 ;
23496 char * kwnames[] = {
23497 (char *) "self",(char *) "millisecond", NULL
23498 };
23499
23500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23502 if (!SWIG_IsOK(res1)) {
23503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23504 }
23505 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23506 ecode2 = SWIG_AsVal_int(obj1, &val2);
23507 if (!SWIG_IsOK(ecode2)) {
23508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23509 }
23510 arg2 = static_cast< int >(val2);
23511 {
23512 PyThreadState* __tstate = wxPyBeginAllowThreads();
23513 {
23514 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23515 result = (wxDateTime *) &_result_ref;
23516 }
23517 wxPyEndAllowThreads(__tstate);
23518 if (PyErr_Occurred()) SWIG_fail;
23519 }
23520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj = 0;
23529 wxDateTime *arg1 = (wxDateTime *) 0 ;
23530 wxDateTime::WeekDay arg2 ;
23531 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23532 wxDateTime *result = 0 ;
23533 void *argp1 = 0 ;
23534 int res1 = 0 ;
23535 int val2 ;
23536 int ecode2 = 0 ;
23537 int val3 ;
23538 int ecode3 = 0 ;
23539 PyObject * obj0 = 0 ;
23540 PyObject * obj1 = 0 ;
23541 PyObject * obj2 = 0 ;
23542 char * kwnames[] = {
23543 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23544 };
23545
23546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23548 if (!SWIG_IsOK(res1)) {
23549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23550 }
23551 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23552 ecode2 = SWIG_AsVal_int(obj1, &val2);
23553 if (!SWIG_IsOK(ecode2)) {
23554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23555 }
23556 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23557 if (obj2) {
23558 ecode3 = SWIG_AsVal_int(obj2, &val3);
23559 if (!SWIG_IsOK(ecode3)) {
23560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23561 }
23562 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23563 }
23564 {
23565 PyThreadState* __tstate = wxPyBeginAllowThreads();
23566 {
23567 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23568 result = (wxDateTime *) &_result_ref;
23569 }
23570 wxPyEndAllowThreads(__tstate);
23571 if (PyErr_Occurred()) SWIG_fail;
23572 }
23573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23581 PyObject *resultobj = 0;
23582 wxDateTime *arg1 = (wxDateTime *) 0 ;
23583 wxDateTime::WeekDay arg2 ;
23584 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23585 wxDateTime result;
23586 void *argp1 = 0 ;
23587 int res1 = 0 ;
23588 int val2 ;
23589 int ecode2 = 0 ;
23590 int val3 ;
23591 int ecode3 = 0 ;
23592 PyObject * obj0 = 0 ;
23593 PyObject * obj1 = 0 ;
23594 PyObject * obj2 = 0 ;
23595 char * kwnames[] = {
23596 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23597 };
23598
23599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23601 if (!SWIG_IsOK(res1)) {
23602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23603 }
23604 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23605 ecode2 = SWIG_AsVal_int(obj1, &val2);
23606 if (!SWIG_IsOK(ecode2)) {
23607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23608 }
23609 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23610 if (obj2) {
23611 ecode3 = SWIG_AsVal_int(obj2, &val3);
23612 if (!SWIG_IsOK(ecode3)) {
23613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23614 }
23615 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23616 }
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23624 return resultobj;
23625 fail:
23626 return NULL;
23627 }
23628
23629
23630 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23631 PyObject *resultobj = 0;
23632 wxDateTime *arg1 = (wxDateTime *) 0 ;
23633 wxDateTime::WeekDay arg2 ;
23634 wxDateTime *result = 0 ;
23635 void *argp1 = 0 ;
23636 int res1 = 0 ;
23637 int val2 ;
23638 int ecode2 = 0 ;
23639 PyObject * obj0 = 0 ;
23640 PyObject * obj1 = 0 ;
23641 char * kwnames[] = {
23642 (char *) "self",(char *) "weekday", NULL
23643 };
23644
23645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23647 if (!SWIG_IsOK(res1)) {
23648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23649 }
23650 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23651 ecode2 = SWIG_AsVal_int(obj1, &val2);
23652 if (!SWIG_IsOK(ecode2)) {
23653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23654 }
23655 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23656 {
23657 PyThreadState* __tstate = wxPyBeginAllowThreads();
23658 {
23659 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23660 result = (wxDateTime *) &_result_ref;
23661 }
23662 wxPyEndAllowThreads(__tstate);
23663 if (PyErr_Occurred()) SWIG_fail;
23664 }
23665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23666 return resultobj;
23667 fail:
23668 return NULL;
23669 }
23670
23671
23672 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23673 PyObject *resultobj = 0;
23674 wxDateTime *arg1 = (wxDateTime *) 0 ;
23675 wxDateTime::WeekDay arg2 ;
23676 wxDateTime result;
23677 void *argp1 = 0 ;
23678 int res1 = 0 ;
23679 int val2 ;
23680 int ecode2 = 0 ;
23681 PyObject * obj0 = 0 ;
23682 PyObject * obj1 = 0 ;
23683 char * kwnames[] = {
23684 (char *) "self",(char *) "weekday", NULL
23685 };
23686
23687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23689 if (!SWIG_IsOK(res1)) {
23690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23691 }
23692 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23693 ecode2 = SWIG_AsVal_int(obj1, &val2);
23694 if (!SWIG_IsOK(ecode2)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23696 }
23697 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23698 {
23699 PyThreadState* __tstate = wxPyBeginAllowThreads();
23700 result = (arg1)->GetNextWeekDay(arg2);
23701 wxPyEndAllowThreads(__tstate);
23702 if (PyErr_Occurred()) SWIG_fail;
23703 }
23704 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23705 return resultobj;
23706 fail:
23707 return NULL;
23708 }
23709
23710
23711 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23712 PyObject *resultobj = 0;
23713 wxDateTime *arg1 = (wxDateTime *) 0 ;
23714 wxDateTime::WeekDay arg2 ;
23715 wxDateTime *result = 0 ;
23716 void *argp1 = 0 ;
23717 int res1 = 0 ;
23718 int val2 ;
23719 int ecode2 = 0 ;
23720 PyObject * obj0 = 0 ;
23721 PyObject * obj1 = 0 ;
23722 char * kwnames[] = {
23723 (char *) "self",(char *) "weekday", NULL
23724 };
23725
23726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23728 if (!SWIG_IsOK(res1)) {
23729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23730 }
23731 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23732 ecode2 = SWIG_AsVal_int(obj1, &val2);
23733 if (!SWIG_IsOK(ecode2)) {
23734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23735 }
23736 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23737 {
23738 PyThreadState* __tstate = wxPyBeginAllowThreads();
23739 {
23740 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23741 result = (wxDateTime *) &_result_ref;
23742 }
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23754 PyObject *resultobj = 0;
23755 wxDateTime *arg1 = (wxDateTime *) 0 ;
23756 wxDateTime::WeekDay arg2 ;
23757 wxDateTime result;
23758 void *argp1 = 0 ;
23759 int res1 = 0 ;
23760 int val2 ;
23761 int ecode2 = 0 ;
23762 PyObject * obj0 = 0 ;
23763 PyObject * obj1 = 0 ;
23764 char * kwnames[] = {
23765 (char *) "self",(char *) "weekday", NULL
23766 };
23767
23768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23770 if (!SWIG_IsOK(res1)) {
23771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23772 }
23773 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23774 ecode2 = SWIG_AsVal_int(obj1, &val2);
23775 if (!SWIG_IsOK(ecode2)) {
23776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23777 }
23778 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 result = (arg1)->GetPrevWeekDay(arg2);
23782 wxPyEndAllowThreads(__tstate);
23783 if (PyErr_Occurred()) SWIG_fail;
23784 }
23785 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23786 return resultobj;
23787 fail:
23788 return NULL;
23789 }
23790
23791
23792 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23793 PyObject *resultobj = 0;
23794 wxDateTime *arg1 = (wxDateTime *) 0 ;
23795 wxDateTime::WeekDay arg2 ;
23796 int arg3 = (int) 1 ;
23797 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23798 int arg5 = (int) wxDateTime::Inv_Year ;
23799 bool result;
23800 void *argp1 = 0 ;
23801 int res1 = 0 ;
23802 int val2 ;
23803 int ecode2 = 0 ;
23804 int val3 ;
23805 int ecode3 = 0 ;
23806 int val4 ;
23807 int ecode4 = 0 ;
23808 int val5 ;
23809 int ecode5 = 0 ;
23810 PyObject * obj0 = 0 ;
23811 PyObject * obj1 = 0 ;
23812 PyObject * obj2 = 0 ;
23813 PyObject * obj3 = 0 ;
23814 PyObject * obj4 = 0 ;
23815 char * kwnames[] = {
23816 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23817 };
23818
23819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23821 if (!SWIG_IsOK(res1)) {
23822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23823 }
23824 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23825 ecode2 = SWIG_AsVal_int(obj1, &val2);
23826 if (!SWIG_IsOK(ecode2)) {
23827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23828 }
23829 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23830 if (obj2) {
23831 ecode3 = SWIG_AsVal_int(obj2, &val3);
23832 if (!SWIG_IsOK(ecode3)) {
23833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23834 }
23835 arg3 = static_cast< int >(val3);
23836 }
23837 if (obj3) {
23838 ecode4 = SWIG_AsVal_int(obj3, &val4);
23839 if (!SWIG_IsOK(ecode4)) {
23840 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23841 }
23842 arg4 = static_cast< wxDateTime::Month >(val4);
23843 }
23844 if (obj4) {
23845 ecode5 = SWIG_AsVal_int(obj4, &val5);
23846 if (!SWIG_IsOK(ecode5)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23848 }
23849 arg5 = static_cast< int >(val5);
23850 }
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 {
23858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23859 }
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23867 PyObject *resultobj = 0;
23868 wxDateTime *arg1 = (wxDateTime *) 0 ;
23869 wxDateTime::WeekDay arg2 ;
23870 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23871 int arg4 = (int) wxDateTime::Inv_Year ;
23872 bool result;
23873 void *argp1 = 0 ;
23874 int res1 = 0 ;
23875 int val2 ;
23876 int ecode2 = 0 ;
23877 int val3 ;
23878 int ecode3 = 0 ;
23879 int val4 ;
23880 int ecode4 = 0 ;
23881 PyObject * obj0 = 0 ;
23882 PyObject * obj1 = 0 ;
23883 PyObject * obj2 = 0 ;
23884 PyObject * obj3 = 0 ;
23885 char * kwnames[] = {
23886 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23887 };
23888
23889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23891 if (!SWIG_IsOK(res1)) {
23892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23893 }
23894 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23895 ecode2 = SWIG_AsVal_int(obj1, &val2);
23896 if (!SWIG_IsOK(ecode2)) {
23897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23898 }
23899 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23900 if (obj2) {
23901 ecode3 = SWIG_AsVal_int(obj2, &val3);
23902 if (!SWIG_IsOK(ecode3)) {
23903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23904 }
23905 arg3 = static_cast< wxDateTime::Month >(val3);
23906 }
23907 if (obj3) {
23908 ecode4 = SWIG_AsVal_int(obj3, &val4);
23909 if (!SWIG_IsOK(ecode4)) {
23910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23911 }
23912 arg4 = static_cast< int >(val4);
23913 }
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj = 0;
23931 wxDateTime *arg1 = (wxDateTime *) 0 ;
23932 wxDateTime::WeekDay arg2 ;
23933 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23934 int arg4 = (int) wxDateTime::Inv_Year ;
23935 wxDateTime result;
23936 void *argp1 = 0 ;
23937 int res1 = 0 ;
23938 int val2 ;
23939 int ecode2 = 0 ;
23940 int val3 ;
23941 int ecode3 = 0 ;
23942 int val4 ;
23943 int ecode4 = 0 ;
23944 PyObject * obj0 = 0 ;
23945 PyObject * obj1 = 0 ;
23946 PyObject * obj2 = 0 ;
23947 PyObject * obj3 = 0 ;
23948 char * kwnames[] = {
23949 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23950 };
23951
23952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23954 if (!SWIG_IsOK(res1)) {
23955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23956 }
23957 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23958 ecode2 = SWIG_AsVal_int(obj1, &val2);
23959 if (!SWIG_IsOK(ecode2)) {
23960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23961 }
23962 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23963 if (obj2) {
23964 ecode3 = SWIG_AsVal_int(obj2, &val3);
23965 if (!SWIG_IsOK(ecode3)) {
23966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23967 }
23968 arg3 = static_cast< wxDateTime::Month >(val3);
23969 }
23970 if (obj3) {
23971 ecode4 = SWIG_AsVal_int(obj3, &val4);
23972 if (!SWIG_IsOK(ecode4)) {
23973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23974 }
23975 arg4 = static_cast< int >(val4);
23976 }
23977 {
23978 PyThreadState* __tstate = wxPyBeginAllowThreads();
23979 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23991 PyObject *resultobj = 0;
23992 wxDateTime *arg1 = (wxDateTime *) 0 ;
23993 int arg2 ;
23994 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23995 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23996 bool result;
23997 void *argp1 = 0 ;
23998 int res1 = 0 ;
23999 int val2 ;
24000 int ecode2 = 0 ;
24001 int val3 ;
24002 int ecode3 = 0 ;
24003 int val4 ;
24004 int ecode4 = 0 ;
24005 PyObject * obj0 = 0 ;
24006 PyObject * obj1 = 0 ;
24007 PyObject * obj2 = 0 ;
24008 PyObject * obj3 = 0 ;
24009 char * kwnames[] = {
24010 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24011 };
24012
24013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24015 if (!SWIG_IsOK(res1)) {
24016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24017 }
24018 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24019 ecode2 = SWIG_AsVal_int(obj1, &val2);
24020 if (!SWIG_IsOK(ecode2)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24022 }
24023 arg2 = static_cast< int >(val2);
24024 if (obj2) {
24025 ecode3 = SWIG_AsVal_int(obj2, &val3);
24026 if (!SWIG_IsOK(ecode3)) {
24027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24028 }
24029 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24030 }
24031 if (obj3) {
24032 ecode4 = SWIG_AsVal_int(obj3, &val4);
24033 if (!SWIG_IsOK(ecode4)) {
24034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24035 }
24036 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24037 }
24038 {
24039 PyThreadState* __tstate = wxPyBeginAllowThreads();
24040 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 {
24045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24046 }
24047 return resultobj;
24048 fail:
24049 return NULL;
24050 }
24051
24052
24053 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24054 PyObject *resultobj = 0;
24055 wxDateTime *arg1 = (wxDateTime *) 0 ;
24056 int arg2 ;
24057 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24058 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24059 wxDateTime result;
24060 void *argp1 = 0 ;
24061 int res1 = 0 ;
24062 int val2 ;
24063 int ecode2 = 0 ;
24064 int val3 ;
24065 int ecode3 = 0 ;
24066 int val4 ;
24067 int ecode4 = 0 ;
24068 PyObject * obj0 = 0 ;
24069 PyObject * obj1 = 0 ;
24070 PyObject * obj2 = 0 ;
24071 PyObject * obj3 = 0 ;
24072 char * kwnames[] = {
24073 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24074 };
24075
24076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24078 if (!SWIG_IsOK(res1)) {
24079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24080 }
24081 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24082 ecode2 = SWIG_AsVal_int(obj1, &val2);
24083 if (!SWIG_IsOK(ecode2)) {
24084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
24085 }
24086 arg2 = static_cast< int >(val2);
24087 if (obj2) {
24088 ecode3 = SWIG_AsVal_int(obj2, &val3);
24089 if (!SWIG_IsOK(ecode3)) {
24090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24091 }
24092 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24093 }
24094 if (obj3) {
24095 ecode4 = SWIG_AsVal_int(obj3, &val4);
24096 if (!SWIG_IsOK(ecode4)) {
24097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24098 }
24099 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24100 }
24101 {
24102 PyThreadState* __tstate = wxPyBeginAllowThreads();
24103 result = (arg1)->GetWeek(arg2,arg3,arg4);
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj = 0;
24116 int arg1 ;
24117 int arg2 ;
24118 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24119 wxDateTime result;
24120 int val1 ;
24121 int ecode1 = 0 ;
24122 int val2 ;
24123 int ecode2 = 0 ;
24124 int val3 ;
24125 int ecode3 = 0 ;
24126 PyObject * obj0 = 0 ;
24127 PyObject * obj1 = 0 ;
24128 PyObject * obj2 = 0 ;
24129 char * kwnames[] = {
24130 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24131 };
24132
24133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24134 ecode1 = SWIG_AsVal_int(obj0, &val1);
24135 if (!SWIG_IsOK(ecode1)) {
24136 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24137 }
24138 arg1 = static_cast< int >(val1);
24139 ecode2 = SWIG_AsVal_int(obj1, &val2);
24140 if (!SWIG_IsOK(ecode2)) {
24141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24142 }
24143 arg2 = static_cast< int >(val2);
24144 if (obj2) {
24145 ecode3 = SWIG_AsVal_int(obj2, &val3);
24146 if (!SWIG_IsOK(ecode3)) {
24147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24148 }
24149 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24150 }
24151 {
24152 PyThreadState* __tstate = wxPyBeginAllowThreads();
24153 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24154 wxPyEndAllowThreads(__tstate);
24155 if (PyErr_Occurred()) SWIG_fail;
24156 }
24157 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24158 return resultobj;
24159 fail:
24160 return NULL;
24161 }
24162
24163
24164 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24165 PyObject *resultobj = 0;
24166 wxDateTime *arg1 = (wxDateTime *) 0 ;
24167 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24168 int arg3 = (int) wxDateTime::Inv_Year ;
24169 wxDateTime *result = 0 ;
24170 void *argp1 = 0 ;
24171 int res1 = 0 ;
24172 int val2 ;
24173 int ecode2 = 0 ;
24174 int val3 ;
24175 int ecode3 = 0 ;
24176 PyObject * obj0 = 0 ;
24177 PyObject * obj1 = 0 ;
24178 PyObject * obj2 = 0 ;
24179 char * kwnames[] = {
24180 (char *) "self",(char *) "month",(char *) "year", NULL
24181 };
24182
24183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24185 if (!SWIG_IsOK(res1)) {
24186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24187 }
24188 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24189 if (obj1) {
24190 ecode2 = SWIG_AsVal_int(obj1, &val2);
24191 if (!SWIG_IsOK(ecode2)) {
24192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24193 }
24194 arg2 = static_cast< wxDateTime::Month >(val2);
24195 }
24196 if (obj2) {
24197 ecode3 = SWIG_AsVal_int(obj2, &val3);
24198 if (!SWIG_IsOK(ecode3)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24200 }
24201 arg3 = static_cast< int >(val3);
24202 }
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 {
24206 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24207 result = (wxDateTime *) &_result_ref;
24208 }
24209 wxPyEndAllowThreads(__tstate);
24210 if (PyErr_Occurred()) SWIG_fail;
24211 }
24212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24213 return resultobj;
24214 fail:
24215 return NULL;
24216 }
24217
24218
24219 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24220 PyObject *resultobj = 0;
24221 wxDateTime *arg1 = (wxDateTime *) 0 ;
24222 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24223 int arg3 = (int) wxDateTime::Inv_Year ;
24224 wxDateTime result;
24225 void *argp1 = 0 ;
24226 int res1 = 0 ;
24227 int val2 ;
24228 int ecode2 = 0 ;
24229 int val3 ;
24230 int ecode3 = 0 ;
24231 PyObject * obj0 = 0 ;
24232 PyObject * obj1 = 0 ;
24233 PyObject * obj2 = 0 ;
24234 char * kwnames[] = {
24235 (char *) "self",(char *) "month",(char *) "year", NULL
24236 };
24237
24238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24240 if (!SWIG_IsOK(res1)) {
24241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24242 }
24243 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24244 if (obj1) {
24245 ecode2 = SWIG_AsVal_int(obj1, &val2);
24246 if (!SWIG_IsOK(ecode2)) {
24247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24248 }
24249 arg2 = static_cast< wxDateTime::Month >(val2);
24250 }
24251 if (obj2) {
24252 ecode3 = SWIG_AsVal_int(obj2, &val3);
24253 if (!SWIG_IsOK(ecode3)) {
24254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24255 }
24256 arg3 = static_cast< int >(val3);
24257 }
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 result = (arg1)->GetLastMonthDay(arg2,arg3);
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24272 PyObject *resultobj = 0;
24273 wxDateTime *arg1 = (wxDateTime *) 0 ;
24274 int arg2 ;
24275 wxDateTime *result = 0 ;
24276 void *argp1 = 0 ;
24277 int res1 = 0 ;
24278 int val2 ;
24279 int ecode2 = 0 ;
24280 PyObject * obj0 = 0 ;
24281 PyObject * obj1 = 0 ;
24282 char * kwnames[] = {
24283 (char *) "self",(char *) "yday", NULL
24284 };
24285
24286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24288 if (!SWIG_IsOK(res1)) {
24289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24290 }
24291 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24292 ecode2 = SWIG_AsVal_int(obj1, &val2);
24293 if (!SWIG_IsOK(ecode2)) {
24294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24295 }
24296 arg2 = static_cast< int >(val2);
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 {
24300 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24301 result = (wxDateTime *) &_result_ref;
24302 }
24303 wxPyEndAllowThreads(__tstate);
24304 if (PyErr_Occurred()) SWIG_fail;
24305 }
24306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24307 return resultobj;
24308 fail:
24309 return NULL;
24310 }
24311
24312
24313 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24314 PyObject *resultobj = 0;
24315 wxDateTime *arg1 = (wxDateTime *) 0 ;
24316 int arg2 ;
24317 wxDateTime result;
24318 void *argp1 = 0 ;
24319 int res1 = 0 ;
24320 int val2 ;
24321 int ecode2 = 0 ;
24322 PyObject * obj0 = 0 ;
24323 PyObject * obj1 = 0 ;
24324 char * kwnames[] = {
24325 (char *) "self",(char *) "yday", NULL
24326 };
24327
24328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24330 if (!SWIG_IsOK(res1)) {
24331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24332 }
24333 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24334 ecode2 = SWIG_AsVal_int(obj1, &val2);
24335 if (!SWIG_IsOK(ecode2)) {
24336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24337 }
24338 arg2 = static_cast< int >(val2);
24339 {
24340 PyThreadState* __tstate = wxPyBeginAllowThreads();
24341 result = (arg1)->GetYearDay(arg2);
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24353 PyObject *resultobj = 0;
24354 wxDateTime *arg1 = (wxDateTime *) 0 ;
24355 double result;
24356 void *argp1 = 0 ;
24357 int res1 = 0 ;
24358 PyObject *swig_obj[1] ;
24359
24360 if (!args) SWIG_fail;
24361 swig_obj[0] = args;
24362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24363 if (!SWIG_IsOK(res1)) {
24364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24365 }
24366 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24367 {
24368 PyThreadState* __tstate = wxPyBeginAllowThreads();
24369 result = (double)(arg1)->GetJulianDayNumber();
24370 wxPyEndAllowThreads(__tstate);
24371 if (PyErr_Occurred()) SWIG_fail;
24372 }
24373 resultobj = SWIG_From_double(static_cast< double >(result));
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24381 PyObject *resultobj = 0;
24382 wxDateTime *arg1 = (wxDateTime *) 0 ;
24383 double result;
24384 void *argp1 = 0 ;
24385 int res1 = 0 ;
24386 PyObject *swig_obj[1] ;
24387
24388 if (!args) SWIG_fail;
24389 swig_obj[0] = args;
24390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24391 if (!SWIG_IsOK(res1)) {
24392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24393 }
24394 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 result = (double)(arg1)->GetJDN();
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 resultobj = SWIG_From_double(static_cast< double >(result));
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24409 PyObject *resultobj = 0;
24410 wxDateTime *arg1 = (wxDateTime *) 0 ;
24411 double result;
24412 void *argp1 = 0 ;
24413 int res1 = 0 ;
24414 PyObject *swig_obj[1] ;
24415
24416 if (!args) SWIG_fail;
24417 swig_obj[0] = args;
24418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24419 if (!SWIG_IsOK(res1)) {
24420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24421 }
24422 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24423 {
24424 PyThreadState* __tstate = wxPyBeginAllowThreads();
24425 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 resultobj = SWIG_From_double(static_cast< double >(result));
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24437 PyObject *resultobj = 0;
24438 wxDateTime *arg1 = (wxDateTime *) 0 ;
24439 double result;
24440 void *argp1 = 0 ;
24441 int res1 = 0 ;
24442 PyObject *swig_obj[1] ;
24443
24444 if (!args) SWIG_fail;
24445 swig_obj[0] = args;
24446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24447 if (!SWIG_IsOK(res1)) {
24448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24449 }
24450 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 result = (double)(arg1)->GetMJD();
24454 wxPyEndAllowThreads(__tstate);
24455 if (PyErr_Occurred()) SWIG_fail;
24456 }
24457 resultobj = SWIG_From_double(static_cast< double >(result));
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24465 PyObject *resultobj = 0;
24466 wxDateTime *arg1 = (wxDateTime *) 0 ;
24467 double result;
24468 void *argp1 = 0 ;
24469 int res1 = 0 ;
24470 PyObject *swig_obj[1] ;
24471
24472 if (!args) SWIG_fail;
24473 swig_obj[0] = args;
24474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24475 if (!SWIG_IsOK(res1)) {
24476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24477 }
24478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24479 {
24480 PyThreadState* __tstate = wxPyBeginAllowThreads();
24481 result = (double)(arg1)->GetRataDie();
24482 wxPyEndAllowThreads(__tstate);
24483 if (PyErr_Occurred()) SWIG_fail;
24484 }
24485 resultobj = SWIG_From_double(static_cast< double >(result));
24486 return resultobj;
24487 fail:
24488 return NULL;
24489 }
24490
24491
24492 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24493 PyObject *resultobj = 0;
24494 wxDateTime *arg1 = (wxDateTime *) 0 ;
24495 wxDateTime::TimeZone *arg2 = 0 ;
24496 bool arg3 = (bool) false ;
24497 wxDateTime result;
24498 void *argp1 = 0 ;
24499 int res1 = 0 ;
24500 bool temp2 = false ;
24501 bool val3 ;
24502 int ecode3 = 0 ;
24503 PyObject * obj0 = 0 ;
24504 PyObject * obj1 = 0 ;
24505 PyObject * obj2 = 0 ;
24506 char * kwnames[] = {
24507 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24508 };
24509
24510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24512 if (!SWIG_IsOK(res1)) {
24513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24514 }
24515 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24516 {
24517 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24518 temp2 = true;
24519 }
24520 if (obj2) {
24521 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24522 if (!SWIG_IsOK(ecode3)) {
24523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24524 }
24525 arg3 = static_cast< bool >(val3);
24526 }
24527 {
24528 PyThreadState* __tstate = wxPyBeginAllowThreads();
24529 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24530 wxPyEndAllowThreads(__tstate);
24531 if (PyErr_Occurred()) SWIG_fail;
24532 }
24533 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24534 {
24535 if (temp2) delete arg2;
24536 }
24537 return resultobj;
24538 fail:
24539 {
24540 if (temp2) delete arg2;
24541 }
24542 return NULL;
24543 }
24544
24545
24546 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24547 PyObject *resultobj = 0;
24548 wxDateTime *arg1 = (wxDateTime *) 0 ;
24549 wxDateTime::TimeZone *arg2 = 0 ;
24550 bool arg3 = (bool) false ;
24551 wxDateTime *result = 0 ;
24552 void *argp1 = 0 ;
24553 int res1 = 0 ;
24554 bool temp2 = false ;
24555 bool val3 ;
24556 int ecode3 = 0 ;
24557 PyObject * obj0 = 0 ;
24558 PyObject * obj1 = 0 ;
24559 PyObject * obj2 = 0 ;
24560 char * kwnames[] = {
24561 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24562 };
24563
24564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24566 if (!SWIG_IsOK(res1)) {
24567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24568 }
24569 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24570 {
24571 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24572 temp2 = true;
24573 }
24574 if (obj2) {
24575 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24576 if (!SWIG_IsOK(ecode3)) {
24577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24578 }
24579 arg3 = static_cast< bool >(val3);
24580 }
24581 {
24582 PyThreadState* __tstate = wxPyBeginAllowThreads();
24583 {
24584 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24585 result = (wxDateTime *) &_result_ref;
24586 }
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24591 {
24592 if (temp2) delete arg2;
24593 }
24594 return resultobj;
24595 fail:
24596 {
24597 if (temp2) delete arg2;
24598 }
24599 return NULL;
24600 }
24601
24602
24603 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj = 0;
24605 wxDateTime *arg1 = (wxDateTime *) 0 ;
24606 wxDateTime::TimeZone *arg2 = 0 ;
24607 bool arg3 = (bool) false ;
24608 wxDateTime result;
24609 void *argp1 = 0 ;
24610 int res1 = 0 ;
24611 bool temp2 = false ;
24612 bool val3 ;
24613 int ecode3 = 0 ;
24614 PyObject * obj0 = 0 ;
24615 PyObject * obj1 = 0 ;
24616 PyObject * obj2 = 0 ;
24617 char * kwnames[] = {
24618 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24619 };
24620
24621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24623 if (!SWIG_IsOK(res1)) {
24624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24625 }
24626 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24627 {
24628 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24629 temp2 = true;
24630 }
24631 if (obj2) {
24632 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24633 if (!SWIG_IsOK(ecode3)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24635 }
24636 arg3 = static_cast< bool >(val3);
24637 }
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24641 wxPyEndAllowThreads(__tstate);
24642 if (PyErr_Occurred()) SWIG_fail;
24643 }
24644 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24645 {
24646 if (temp2) delete arg2;
24647 }
24648 return resultobj;
24649 fail:
24650 {
24651 if (temp2) delete arg2;
24652 }
24653 return NULL;
24654 }
24655
24656
24657 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24658 PyObject *resultobj = 0;
24659 wxDateTime *arg1 = (wxDateTime *) 0 ;
24660 wxDateTime::TimeZone *arg2 = 0 ;
24661 bool arg3 = (bool) false ;
24662 wxDateTime *result = 0 ;
24663 void *argp1 = 0 ;
24664 int res1 = 0 ;
24665 bool temp2 = false ;
24666 bool val3 ;
24667 int ecode3 = 0 ;
24668 PyObject * obj0 = 0 ;
24669 PyObject * obj1 = 0 ;
24670 PyObject * obj2 = 0 ;
24671 char * kwnames[] = {
24672 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24673 };
24674
24675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24677 if (!SWIG_IsOK(res1)) {
24678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24679 }
24680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24681 {
24682 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24683 temp2 = true;
24684 }
24685 if (obj2) {
24686 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24687 if (!SWIG_IsOK(ecode3)) {
24688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24689 }
24690 arg3 = static_cast< bool >(val3);
24691 }
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 {
24695 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24696 result = (wxDateTime *) &_result_ref;
24697 }
24698 wxPyEndAllowThreads(__tstate);
24699 if (PyErr_Occurred()) SWIG_fail;
24700 }
24701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24702 {
24703 if (temp2) delete arg2;
24704 }
24705 return resultobj;
24706 fail:
24707 {
24708 if (temp2) delete arg2;
24709 }
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 wxDateTime *arg1 = (wxDateTime *) 0 ;
24717 bool arg2 = (bool) false ;
24718 wxDateTime result;
24719 void *argp1 = 0 ;
24720 int res1 = 0 ;
24721 bool val2 ;
24722 int ecode2 = 0 ;
24723 PyObject * obj0 = 0 ;
24724 PyObject * obj1 = 0 ;
24725 char * kwnames[] = {
24726 (char *) "self",(char *) "noDST", NULL
24727 };
24728
24729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24731 if (!SWIG_IsOK(res1)) {
24732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24733 }
24734 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24735 if (obj1) {
24736 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24737 if (!SWIG_IsOK(ecode2)) {
24738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24739 }
24740 arg2 = static_cast< bool >(val2);
24741 }
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj = 0;
24757 wxDateTime *arg1 = (wxDateTime *) 0 ;
24758 bool arg2 = (bool) false ;
24759 wxDateTime *result = 0 ;
24760 void *argp1 = 0 ;
24761 int res1 = 0 ;
24762 bool val2 ;
24763 int ecode2 = 0 ;
24764 PyObject * obj0 = 0 ;
24765 PyObject * obj1 = 0 ;
24766 char * kwnames[] = {
24767 (char *) "self",(char *) "noDST", NULL
24768 };
24769
24770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24772 if (!SWIG_IsOK(res1)) {
24773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24774 }
24775 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24776 if (obj1) {
24777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24778 if (!SWIG_IsOK(ecode2)) {
24779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24780 }
24781 arg2 = static_cast< bool >(val2);
24782 }
24783 {
24784 PyThreadState* __tstate = wxPyBeginAllowThreads();
24785 {
24786 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24787 result = (wxDateTime *) &_result_ref;
24788 }
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24800 PyObject *resultobj = 0;
24801 wxDateTime *arg1 = (wxDateTime *) 0 ;
24802 bool arg2 = (bool) false ;
24803 wxDateTime result;
24804 void *argp1 = 0 ;
24805 int res1 = 0 ;
24806 bool val2 ;
24807 int ecode2 = 0 ;
24808 PyObject * obj0 = 0 ;
24809 PyObject * obj1 = 0 ;
24810 char * kwnames[] = {
24811 (char *) "self",(char *) "noDST", NULL
24812 };
24813
24814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24816 if (!SWIG_IsOK(res1)) {
24817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24818 }
24819 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24820 if (obj1) {
24821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24822 if (!SWIG_IsOK(ecode2)) {
24823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24824 }
24825 arg2 = static_cast< bool >(val2);
24826 }
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24830 wxPyEndAllowThreads(__tstate);
24831 if (PyErr_Occurred()) SWIG_fail;
24832 }
24833 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24834 return resultobj;
24835 fail:
24836 return NULL;
24837 }
24838
24839
24840 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24841 PyObject *resultobj = 0;
24842 wxDateTime *arg1 = (wxDateTime *) 0 ;
24843 bool arg2 = (bool) false ;
24844 wxDateTime *result = 0 ;
24845 void *argp1 = 0 ;
24846 int res1 = 0 ;
24847 bool val2 ;
24848 int ecode2 = 0 ;
24849 PyObject * obj0 = 0 ;
24850 PyObject * obj1 = 0 ;
24851 char * kwnames[] = {
24852 (char *) "self",(char *) "noDST", NULL
24853 };
24854
24855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24859 }
24860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24861 if (obj1) {
24862 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24863 if (!SWIG_IsOK(ecode2)) {
24864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24865 }
24866 arg2 = static_cast< bool >(val2);
24867 }
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 {
24871 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24872 result = (wxDateTime *) &_result_ref;
24873 }
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24878 return resultobj;
24879 fail:
24880 return NULL;
24881 }
24882
24883
24884 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24885 PyObject *resultobj = 0;
24886 wxDateTime *arg1 = (wxDateTime *) 0 ;
24887 bool arg2 = (bool) false ;
24888 wxDateTime result;
24889 void *argp1 = 0 ;
24890 int res1 = 0 ;
24891 bool val2 ;
24892 int ecode2 = 0 ;
24893 PyObject * obj0 = 0 ;
24894 PyObject * obj1 = 0 ;
24895 char * kwnames[] = {
24896 (char *) "self",(char *) "noDST", NULL
24897 };
24898
24899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24901 if (!SWIG_IsOK(res1)) {
24902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24903 }
24904 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24905 if (obj1) {
24906 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24907 if (!SWIG_IsOK(ecode2)) {
24908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24909 }
24910 arg2 = static_cast< bool >(val2);
24911 }
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24915 wxPyEndAllowThreads(__tstate);
24916 if (PyErr_Occurred()) SWIG_fail;
24917 }
24918 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24919 return resultobj;
24920 fail:
24921 return NULL;
24922 }
24923
24924
24925 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24926 PyObject *resultobj = 0;
24927 wxDateTime *arg1 = (wxDateTime *) 0 ;
24928 bool arg2 = (bool) false ;
24929 wxDateTime *result = 0 ;
24930 void *argp1 = 0 ;
24931 int res1 = 0 ;
24932 bool val2 ;
24933 int ecode2 = 0 ;
24934 PyObject * obj0 = 0 ;
24935 PyObject * obj1 = 0 ;
24936 char * kwnames[] = {
24937 (char *) "self",(char *) "noDST", NULL
24938 };
24939
24940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24942 if (!SWIG_IsOK(res1)) {
24943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24944 }
24945 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24946 if (obj1) {
24947 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24948 if (!SWIG_IsOK(ecode2)) {
24949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24950 }
24951 arg2 = static_cast< bool >(val2);
24952 }
24953 {
24954 PyThreadState* __tstate = wxPyBeginAllowThreads();
24955 {
24956 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24957 result = (wxDateTime *) &_result_ref;
24958 }
24959 wxPyEndAllowThreads(__tstate);
24960 if (PyErr_Occurred()) SWIG_fail;
24961 }
24962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj = 0;
24971 wxDateTime *arg1 = (wxDateTime *) 0 ;
24972 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24973 int result;
24974 void *argp1 = 0 ;
24975 int res1 = 0 ;
24976 int val2 ;
24977 int ecode2 = 0 ;
24978 PyObject * obj0 = 0 ;
24979 PyObject * obj1 = 0 ;
24980 char * kwnames[] = {
24981 (char *) "self",(char *) "country", NULL
24982 };
24983
24984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24986 if (!SWIG_IsOK(res1)) {
24987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24988 }
24989 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24990 if (obj1) {
24991 ecode2 = SWIG_AsVal_int(obj1, &val2);
24992 if (!SWIG_IsOK(ecode2)) {
24993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24994 }
24995 arg2 = static_cast< wxDateTime::Country >(val2);
24996 }
24997 {
24998 PyThreadState* __tstate = wxPyBeginAllowThreads();
24999 result = (int)(arg1)->IsDST(arg2);
25000 wxPyEndAllowThreads(__tstate);
25001 if (PyErr_Occurred()) SWIG_fail;
25002 }
25003 resultobj = SWIG_From_int(static_cast< int >(result));
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25011 PyObject *resultobj = 0;
25012 wxDateTime *arg1 = (wxDateTime *) 0 ;
25013 bool result;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 PyObject *swig_obj[1] ;
25017
25018 if (!args) SWIG_fail;
25019 swig_obj[0] = args;
25020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25021 if (!SWIG_IsOK(res1)) {
25022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25023 }
25024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25025 {
25026 PyThreadState* __tstate = wxPyBeginAllowThreads();
25027 result = (bool)((wxDateTime const *)arg1)->IsValid();
25028 wxPyEndAllowThreads(__tstate);
25029 if (PyErr_Occurred()) SWIG_fail;
25030 }
25031 {
25032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25033 }
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25041 PyObject *resultobj = 0;
25042 wxDateTime *arg1 = (wxDateTime *) 0 ;
25043 time_t result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 PyObject *swig_obj[1] ;
25047
25048 if (!args) SWIG_fail;
25049 swig_obj[0] = args;
25050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25053 }
25054 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
25058 wxPyEndAllowThreads(__tstate);
25059 if (PyErr_Occurred()) SWIG_fail;
25060 }
25061 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25062 return resultobj;
25063 fail:
25064 return NULL;
25065 }
25066
25067
25068 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25069 PyObject *resultobj = 0;
25070 wxDateTime *arg1 = (wxDateTime *) 0 ;
25071 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25072 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25073 int result;
25074 void *argp1 = 0 ;
25075 int res1 = 0 ;
25076 bool temp2 = false ;
25077 PyObject * obj0 = 0 ;
25078 PyObject * obj1 = 0 ;
25079 char * kwnames[] = {
25080 (char *) "self",(char *) "tz", NULL
25081 };
25082
25083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
25084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25085 if (!SWIG_IsOK(res1)) {
25086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25087 }
25088 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25089 if (obj1) {
25090 {
25091 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25092 temp2 = true;
25093 }
25094 }
25095 {
25096 PyThreadState* __tstate = wxPyBeginAllowThreads();
25097 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
25098 wxPyEndAllowThreads(__tstate);
25099 if (PyErr_Occurred()) SWIG_fail;
25100 }
25101 resultobj = SWIG_From_int(static_cast< int >(result));
25102 {
25103 if (temp2) delete arg2;
25104 }
25105 return resultobj;
25106 fail:
25107 {
25108 if (temp2) delete arg2;
25109 }
25110 return NULL;
25111 }
25112
25113
25114 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj = 0;
25116 wxDateTime *arg1 = (wxDateTime *) 0 ;
25117 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25118 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25119 wxDateTime::Month result;
25120 void *argp1 = 0 ;
25121 int res1 = 0 ;
25122 bool temp2 = false ;
25123 PyObject * obj0 = 0 ;
25124 PyObject * obj1 = 0 ;
25125 char * kwnames[] = {
25126 (char *) "self",(char *) "tz", NULL
25127 };
25128
25129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25131 if (!SWIG_IsOK(res1)) {
25132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25133 }
25134 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25135 if (obj1) {
25136 {
25137 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25138 temp2 = true;
25139 }
25140 }
25141 {
25142 PyThreadState* __tstate = wxPyBeginAllowThreads();
25143 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25144 wxPyEndAllowThreads(__tstate);
25145 if (PyErr_Occurred()) SWIG_fail;
25146 }
25147 resultobj = SWIG_From_int(static_cast< int >(result));
25148 {
25149 if (temp2) delete arg2;
25150 }
25151 return resultobj;
25152 fail:
25153 {
25154 if (temp2) delete arg2;
25155 }
25156 return NULL;
25157 }
25158
25159
25160 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25161 PyObject *resultobj = 0;
25162 wxDateTime *arg1 = (wxDateTime *) 0 ;
25163 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25164 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25165 int result;
25166 void *argp1 = 0 ;
25167 int res1 = 0 ;
25168 bool temp2 = false ;
25169 PyObject * obj0 = 0 ;
25170 PyObject * obj1 = 0 ;
25171 char * kwnames[] = {
25172 (char *) "self",(char *) "tz", NULL
25173 };
25174
25175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25177 if (!SWIG_IsOK(res1)) {
25178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25179 }
25180 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25181 if (obj1) {
25182 {
25183 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25184 temp2 = true;
25185 }
25186 }
25187 {
25188 PyThreadState* __tstate = wxPyBeginAllowThreads();
25189 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25190 wxPyEndAllowThreads(__tstate);
25191 if (PyErr_Occurred()) SWIG_fail;
25192 }
25193 resultobj = SWIG_From_int(static_cast< int >(result));
25194 {
25195 if (temp2) delete arg2;
25196 }
25197 return resultobj;
25198 fail:
25199 {
25200 if (temp2) delete arg2;
25201 }
25202 return NULL;
25203 }
25204
25205
25206 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25207 PyObject *resultobj = 0;
25208 wxDateTime *arg1 = (wxDateTime *) 0 ;
25209 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25210 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25211 wxDateTime::WeekDay result;
25212 void *argp1 = 0 ;
25213 int res1 = 0 ;
25214 bool temp2 = false ;
25215 PyObject * obj0 = 0 ;
25216 PyObject * obj1 = 0 ;
25217 char * kwnames[] = {
25218 (char *) "self",(char *) "tz", NULL
25219 };
25220
25221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25223 if (!SWIG_IsOK(res1)) {
25224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25225 }
25226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25227 if (obj1) {
25228 {
25229 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25230 temp2 = true;
25231 }
25232 }
25233 {
25234 PyThreadState* __tstate = wxPyBeginAllowThreads();
25235 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25236 wxPyEndAllowThreads(__tstate);
25237 if (PyErr_Occurred()) SWIG_fail;
25238 }
25239 resultobj = SWIG_From_int(static_cast< int >(result));
25240 {
25241 if (temp2) delete arg2;
25242 }
25243 return resultobj;
25244 fail:
25245 {
25246 if (temp2) delete arg2;
25247 }
25248 return NULL;
25249 }
25250
25251
25252 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj = 0;
25254 wxDateTime *arg1 = (wxDateTime *) 0 ;
25255 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25256 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25257 int result;
25258 void *argp1 = 0 ;
25259 int res1 = 0 ;
25260 bool temp2 = false ;
25261 PyObject * obj0 = 0 ;
25262 PyObject * obj1 = 0 ;
25263 char * kwnames[] = {
25264 (char *) "self",(char *) "tz", NULL
25265 };
25266
25267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25269 if (!SWIG_IsOK(res1)) {
25270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25271 }
25272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25273 if (obj1) {
25274 {
25275 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25276 temp2 = true;
25277 }
25278 }
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 resultobj = SWIG_From_int(static_cast< int >(result));
25286 {
25287 if (temp2) delete arg2;
25288 }
25289 return resultobj;
25290 fail:
25291 {
25292 if (temp2) delete arg2;
25293 }
25294 return NULL;
25295 }
25296
25297
25298 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25299 PyObject *resultobj = 0;
25300 wxDateTime *arg1 = (wxDateTime *) 0 ;
25301 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25302 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25303 int result;
25304 void *argp1 = 0 ;
25305 int res1 = 0 ;
25306 bool temp2 = false ;
25307 PyObject * obj0 = 0 ;
25308 PyObject * obj1 = 0 ;
25309 char * kwnames[] = {
25310 (char *) "self",(char *) "tz", NULL
25311 };
25312
25313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25315 if (!SWIG_IsOK(res1)) {
25316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25317 }
25318 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25319 if (obj1) {
25320 {
25321 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25322 temp2 = true;
25323 }
25324 }
25325 {
25326 PyThreadState* __tstate = wxPyBeginAllowThreads();
25327 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25328 wxPyEndAllowThreads(__tstate);
25329 if (PyErr_Occurred()) SWIG_fail;
25330 }
25331 resultobj = SWIG_From_int(static_cast< int >(result));
25332 {
25333 if (temp2) delete arg2;
25334 }
25335 return resultobj;
25336 fail:
25337 {
25338 if (temp2) delete arg2;
25339 }
25340 return NULL;
25341 }
25342
25343
25344 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25345 PyObject *resultobj = 0;
25346 wxDateTime *arg1 = (wxDateTime *) 0 ;
25347 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25348 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25349 int result;
25350 void *argp1 = 0 ;
25351 int res1 = 0 ;
25352 bool temp2 = false ;
25353 PyObject * obj0 = 0 ;
25354 PyObject * obj1 = 0 ;
25355 char * kwnames[] = {
25356 (char *) "self",(char *) "tz", NULL
25357 };
25358
25359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25361 if (!SWIG_IsOK(res1)) {
25362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25363 }
25364 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25365 if (obj1) {
25366 {
25367 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25368 temp2 = true;
25369 }
25370 }
25371 {
25372 PyThreadState* __tstate = wxPyBeginAllowThreads();
25373 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25374 wxPyEndAllowThreads(__tstate);
25375 if (PyErr_Occurred()) SWIG_fail;
25376 }
25377 resultobj = SWIG_From_int(static_cast< int >(result));
25378 {
25379 if (temp2) delete arg2;
25380 }
25381 return resultobj;
25382 fail:
25383 {
25384 if (temp2) delete arg2;
25385 }
25386 return NULL;
25387 }
25388
25389
25390 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25391 PyObject *resultobj = 0;
25392 wxDateTime *arg1 = (wxDateTime *) 0 ;
25393 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25394 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25395 int result;
25396 void *argp1 = 0 ;
25397 int res1 = 0 ;
25398 bool temp2 = false ;
25399 PyObject * obj0 = 0 ;
25400 PyObject * obj1 = 0 ;
25401 char * kwnames[] = {
25402 (char *) "self",(char *) "tz", NULL
25403 };
25404
25405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25407 if (!SWIG_IsOK(res1)) {
25408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25409 }
25410 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25411 if (obj1) {
25412 {
25413 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25414 temp2 = true;
25415 }
25416 }
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25420 wxPyEndAllowThreads(__tstate);
25421 if (PyErr_Occurred()) SWIG_fail;
25422 }
25423 resultobj = SWIG_From_int(static_cast< int >(result));
25424 {
25425 if (temp2) delete arg2;
25426 }
25427 return resultobj;
25428 fail:
25429 {
25430 if (temp2) delete arg2;
25431 }
25432 return NULL;
25433 }
25434
25435
25436 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25437 PyObject *resultobj = 0;
25438 wxDateTime *arg1 = (wxDateTime *) 0 ;
25439 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25440 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25441 int result;
25442 void *argp1 = 0 ;
25443 int res1 = 0 ;
25444 bool temp2 = false ;
25445 PyObject * obj0 = 0 ;
25446 PyObject * obj1 = 0 ;
25447 char * kwnames[] = {
25448 (char *) "self",(char *) "tz", NULL
25449 };
25450
25451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25453 if (!SWIG_IsOK(res1)) {
25454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25455 }
25456 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25457 if (obj1) {
25458 {
25459 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25460 temp2 = true;
25461 }
25462 }
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 resultobj = SWIG_From_int(static_cast< int >(result));
25470 {
25471 if (temp2) delete arg2;
25472 }
25473 return resultobj;
25474 fail:
25475 {
25476 if (temp2) delete arg2;
25477 }
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25483 PyObject *resultobj = 0;
25484 wxDateTime *arg1 = (wxDateTime *) 0 ;
25485 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25486 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25487 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25488 int result;
25489 void *argp1 = 0 ;
25490 int res1 = 0 ;
25491 int val2 ;
25492 int ecode2 = 0 ;
25493 bool temp3 = false ;
25494 PyObject * obj0 = 0 ;
25495 PyObject * obj1 = 0 ;
25496 PyObject * obj2 = 0 ;
25497 char * kwnames[] = {
25498 (char *) "self",(char *) "flags",(char *) "tz", NULL
25499 };
25500
25501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25503 if (!SWIG_IsOK(res1)) {
25504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25505 }
25506 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25507 if (obj1) {
25508 ecode2 = SWIG_AsVal_int(obj1, &val2);
25509 if (!SWIG_IsOK(ecode2)) {
25510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25511 }
25512 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25513 }
25514 if (obj2) {
25515 {
25516 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25517 temp3 = true;
25518 }
25519 }
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25523 wxPyEndAllowThreads(__tstate);
25524 if (PyErr_Occurred()) SWIG_fail;
25525 }
25526 resultobj = SWIG_From_int(static_cast< int >(result));
25527 {
25528 if (temp3) delete arg3;
25529 }
25530 return resultobj;
25531 fail:
25532 {
25533 if (temp3) delete arg3;
25534 }
25535 return NULL;
25536 }
25537
25538
25539 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj = 0;
25541 wxDateTime *arg1 = (wxDateTime *) 0 ;
25542 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25543 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25544 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25545 int result;
25546 void *argp1 = 0 ;
25547 int res1 = 0 ;
25548 int val2 ;
25549 int ecode2 = 0 ;
25550 bool temp3 = false ;
25551 PyObject * obj0 = 0 ;
25552 PyObject * obj1 = 0 ;
25553 PyObject * obj2 = 0 ;
25554 char * kwnames[] = {
25555 (char *) "self",(char *) "flags",(char *) "tz", NULL
25556 };
25557
25558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25560 if (!SWIG_IsOK(res1)) {
25561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25562 }
25563 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25564 if (obj1) {
25565 ecode2 = SWIG_AsVal_int(obj1, &val2);
25566 if (!SWIG_IsOK(ecode2)) {
25567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25568 }
25569 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25570 }
25571 if (obj2) {
25572 {
25573 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25574 temp3 = true;
25575 }
25576 }
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_From_int(static_cast< int >(result));
25584 {
25585 if (temp3) delete arg3;
25586 }
25587 return resultobj;
25588 fail:
25589 {
25590 if (temp3) delete arg3;
25591 }
25592 return NULL;
25593 }
25594
25595
25596 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25597 PyObject *resultobj = 0;
25598 wxDateTime *arg1 = (wxDateTime *) 0 ;
25599 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25600 bool result;
25601 void *argp1 = 0 ;
25602 int res1 = 0 ;
25603 int val2 ;
25604 int ecode2 = 0 ;
25605 PyObject * obj0 = 0 ;
25606 PyObject * obj1 = 0 ;
25607 char * kwnames[] = {
25608 (char *) "self",(char *) "country", NULL
25609 };
25610
25611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25613 if (!SWIG_IsOK(res1)) {
25614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25615 }
25616 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25617 if (obj1) {
25618 ecode2 = SWIG_AsVal_int(obj1, &val2);
25619 if (!SWIG_IsOK(ecode2)) {
25620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25621 }
25622 arg2 = static_cast< wxDateTime::Country >(val2);
25623 }
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 {
25631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25632 }
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25640 PyObject *resultobj = 0;
25641 wxDateTime *arg1 = (wxDateTime *) 0 ;
25642 wxDateTime *arg2 = 0 ;
25643 bool result;
25644 void *argp1 = 0 ;
25645 int res1 = 0 ;
25646 void *argp2 = 0 ;
25647 int res2 = 0 ;
25648 PyObject * obj0 = 0 ;
25649 PyObject * obj1 = 0 ;
25650 char * kwnames[] = {
25651 (char *) "self",(char *) "datetime", NULL
25652 };
25653
25654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25656 if (!SWIG_IsOK(res1)) {
25657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25658 }
25659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25660 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25661 if (!SWIG_IsOK(res2)) {
25662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25663 }
25664 if (!argp2) {
25665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25666 }
25667 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25668 {
25669 PyThreadState* __tstate = wxPyBeginAllowThreads();
25670 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25671 wxPyEndAllowThreads(__tstate);
25672 if (PyErr_Occurred()) SWIG_fail;
25673 }
25674 {
25675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25676 }
25677 return resultobj;
25678 fail:
25679 return NULL;
25680 }
25681
25682
25683 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25684 PyObject *resultobj = 0;
25685 wxDateTime *arg1 = (wxDateTime *) 0 ;
25686 wxDateTime *arg2 = 0 ;
25687 bool result;
25688 void *argp1 = 0 ;
25689 int res1 = 0 ;
25690 void *argp2 = 0 ;
25691 int res2 = 0 ;
25692 PyObject * obj0 = 0 ;
25693 PyObject * obj1 = 0 ;
25694 char * kwnames[] = {
25695 (char *) "self",(char *) "datetime", NULL
25696 };
25697
25698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25702 }
25703 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25704 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25705 if (!SWIG_IsOK(res2)) {
25706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25707 }
25708 if (!argp2) {
25709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25710 }
25711 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25712 {
25713 PyThreadState* __tstate = wxPyBeginAllowThreads();
25714 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25715 wxPyEndAllowThreads(__tstate);
25716 if (PyErr_Occurred()) SWIG_fail;
25717 }
25718 {
25719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25720 }
25721 return resultobj;
25722 fail:
25723 return NULL;
25724 }
25725
25726
25727 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj = 0;
25729 wxDateTime *arg1 = (wxDateTime *) 0 ;
25730 wxDateTime *arg2 = 0 ;
25731 bool result;
25732 void *argp1 = 0 ;
25733 int res1 = 0 ;
25734 void *argp2 = 0 ;
25735 int res2 = 0 ;
25736 PyObject * obj0 = 0 ;
25737 PyObject * obj1 = 0 ;
25738 char * kwnames[] = {
25739 (char *) "self",(char *) "datetime", NULL
25740 };
25741
25742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25746 }
25747 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25748 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25749 if (!SWIG_IsOK(res2)) {
25750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25751 }
25752 if (!argp2) {
25753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25754 }
25755 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25759 wxPyEndAllowThreads(__tstate);
25760 if (PyErr_Occurred()) SWIG_fail;
25761 }
25762 {
25763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25764 }
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25772 PyObject *resultobj = 0;
25773 wxDateTime *arg1 = (wxDateTime *) 0 ;
25774 wxDateTime *arg2 = 0 ;
25775 wxDateTime *arg3 = 0 ;
25776 bool result;
25777 void *argp1 = 0 ;
25778 int res1 = 0 ;
25779 void *argp2 = 0 ;
25780 int res2 = 0 ;
25781 void *argp3 = 0 ;
25782 int res3 = 0 ;
25783 PyObject * obj0 = 0 ;
25784 PyObject * obj1 = 0 ;
25785 PyObject * obj2 = 0 ;
25786 char * kwnames[] = {
25787 (char *) "self",(char *) "t1",(char *) "t2", NULL
25788 };
25789
25790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25792 if (!SWIG_IsOK(res1)) {
25793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25794 }
25795 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25797 if (!SWIG_IsOK(res2)) {
25798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25799 }
25800 if (!argp2) {
25801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25802 }
25803 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25804 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25805 if (!SWIG_IsOK(res3)) {
25806 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25807 }
25808 if (!argp3) {
25809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25810 }
25811 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 {
25819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25820 }
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = 0;
25829 wxDateTime *arg1 = (wxDateTime *) 0 ;
25830 wxDateTime *arg2 = 0 ;
25831 wxDateTime *arg3 = 0 ;
25832 bool result;
25833 void *argp1 = 0 ;
25834 int res1 = 0 ;
25835 void *argp2 = 0 ;
25836 int res2 = 0 ;
25837 void *argp3 = 0 ;
25838 int res3 = 0 ;
25839 PyObject * obj0 = 0 ;
25840 PyObject * obj1 = 0 ;
25841 PyObject * obj2 = 0 ;
25842 char * kwnames[] = {
25843 (char *) "self",(char *) "t1",(char *) "t2", NULL
25844 };
25845
25846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25848 if (!SWIG_IsOK(res1)) {
25849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25850 }
25851 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25852 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25853 if (!SWIG_IsOK(res2)) {
25854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25855 }
25856 if (!argp2) {
25857 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25858 }
25859 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25860 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25861 if (!SWIG_IsOK(res3)) {
25862 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25863 }
25864 if (!argp3) {
25865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25866 }
25867 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25868 {
25869 PyThreadState* __tstate = wxPyBeginAllowThreads();
25870 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 {
25875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25876 }
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25884 PyObject *resultobj = 0;
25885 wxDateTime *arg1 = (wxDateTime *) 0 ;
25886 wxDateTime *arg2 = 0 ;
25887 bool result;
25888 void *argp1 = 0 ;
25889 int res1 = 0 ;
25890 void *argp2 = 0 ;
25891 int res2 = 0 ;
25892 PyObject * obj0 = 0 ;
25893 PyObject * obj1 = 0 ;
25894 char * kwnames[] = {
25895 (char *) "self",(char *) "dt", NULL
25896 };
25897
25898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25900 if (!SWIG_IsOK(res1)) {
25901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25902 }
25903 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25905 if (!SWIG_IsOK(res2)) {
25906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25907 }
25908 if (!argp2) {
25909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25910 }
25911 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25912 {
25913 PyThreadState* __tstate = wxPyBeginAllowThreads();
25914 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25915 wxPyEndAllowThreads(__tstate);
25916 if (PyErr_Occurred()) SWIG_fail;
25917 }
25918 {
25919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25920 }
25921 return resultobj;
25922 fail:
25923 return NULL;
25924 }
25925
25926
25927 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25928 PyObject *resultobj = 0;
25929 wxDateTime *arg1 = (wxDateTime *) 0 ;
25930 wxDateTime *arg2 = 0 ;
25931 bool result;
25932 void *argp1 = 0 ;
25933 int res1 = 0 ;
25934 void *argp2 = 0 ;
25935 int res2 = 0 ;
25936 PyObject * obj0 = 0 ;
25937 PyObject * obj1 = 0 ;
25938 char * kwnames[] = {
25939 (char *) "self",(char *) "dt", NULL
25940 };
25941
25942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25944 if (!SWIG_IsOK(res1)) {
25945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25946 }
25947 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25949 if (!SWIG_IsOK(res2)) {
25950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25951 }
25952 if (!argp2) {
25953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25954 }
25955 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25956 {
25957 PyThreadState* __tstate = wxPyBeginAllowThreads();
25958 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 {
25963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25964 }
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25972 PyObject *resultobj = 0;
25973 wxDateTime *arg1 = (wxDateTime *) 0 ;
25974 wxDateTime *arg2 = 0 ;
25975 wxTimeSpan *arg3 = 0 ;
25976 bool result;
25977 void *argp1 = 0 ;
25978 int res1 = 0 ;
25979 void *argp2 = 0 ;
25980 int res2 = 0 ;
25981 void *argp3 = 0 ;
25982 int res3 = 0 ;
25983 PyObject * obj0 = 0 ;
25984 PyObject * obj1 = 0 ;
25985 PyObject * obj2 = 0 ;
25986 char * kwnames[] = {
25987 (char *) "self",(char *) "dt",(char *) "ts", NULL
25988 };
25989
25990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25992 if (!SWIG_IsOK(res1)) {
25993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25994 }
25995 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25996 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25997 if (!SWIG_IsOK(res2)) {
25998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25999 }
26000 if (!argp2) {
26001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26002 }
26003 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26004 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26005 if (!SWIG_IsOK(res3)) {
26006 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26007 }
26008 if (!argp3) {
26009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26010 }
26011 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 {
26019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26020 }
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj = 0;
26029 wxDateTime *arg1 = (wxDateTime *) 0 ;
26030 wxTimeSpan *arg2 = 0 ;
26031 wxDateTime *result = 0 ;
26032 void *argp1 = 0 ;
26033 int res1 = 0 ;
26034 void *argp2 = 0 ;
26035 int res2 = 0 ;
26036 PyObject * obj0 = 0 ;
26037 PyObject * obj1 = 0 ;
26038 char * kwnames[] = {
26039 (char *) "self",(char *) "diff", NULL
26040 };
26041
26042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
26043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26044 if (!SWIG_IsOK(res1)) {
26045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26046 }
26047 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26048 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26049 if (!SWIG_IsOK(res2)) {
26050 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26051 }
26052 if (!argp2) {
26053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26054 }
26055 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26056 {
26057 PyThreadState* __tstate = wxPyBeginAllowThreads();
26058 {
26059 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
26060 result = (wxDateTime *) &_result_ref;
26061 }
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26066 return resultobj;
26067 fail:
26068 return NULL;
26069 }
26070
26071
26072 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26073 PyObject *resultobj = 0;
26074 wxDateTime *arg1 = (wxDateTime *) 0 ;
26075 wxDateSpan *arg2 = 0 ;
26076 wxDateTime *result = 0 ;
26077 void *argp1 = 0 ;
26078 int res1 = 0 ;
26079 void *argp2 = 0 ;
26080 int res2 = 0 ;
26081 PyObject * obj0 = 0 ;
26082 PyObject * obj1 = 0 ;
26083 char * kwnames[] = {
26084 (char *) "self",(char *) "diff", NULL
26085 };
26086
26087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
26088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26089 if (!SWIG_IsOK(res1)) {
26090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26091 }
26092 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26094 if (!SWIG_IsOK(res2)) {
26095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26096 }
26097 if (!argp2) {
26098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26099 }
26100 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26101 {
26102 PyThreadState* __tstate = wxPyBeginAllowThreads();
26103 {
26104 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26105 result = (wxDateTime *) &_result_ref;
26106 }
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26111 return resultobj;
26112 fail:
26113 return NULL;
26114 }
26115
26116
26117 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26118 PyObject *resultobj = 0;
26119 wxDateTime *arg1 = (wxDateTime *) 0 ;
26120 wxTimeSpan *arg2 = 0 ;
26121 wxDateTime *result = 0 ;
26122 void *argp1 = 0 ;
26123 int res1 = 0 ;
26124 void *argp2 = 0 ;
26125 int res2 = 0 ;
26126 PyObject * obj0 = 0 ;
26127 PyObject * obj1 = 0 ;
26128 char * kwnames[] = {
26129 (char *) "self",(char *) "diff", NULL
26130 };
26131
26132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26134 if (!SWIG_IsOK(res1)) {
26135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26136 }
26137 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26138 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26139 if (!SWIG_IsOK(res2)) {
26140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26141 }
26142 if (!argp2) {
26143 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26144 }
26145 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26146 {
26147 PyThreadState* __tstate = wxPyBeginAllowThreads();
26148 {
26149 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26150 result = (wxDateTime *) &_result_ref;
26151 }
26152 wxPyEndAllowThreads(__tstate);
26153 if (PyErr_Occurred()) SWIG_fail;
26154 }
26155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26156 return resultobj;
26157 fail:
26158 return NULL;
26159 }
26160
26161
26162 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26163 PyObject *resultobj = 0;
26164 wxDateTime *arg1 = (wxDateTime *) 0 ;
26165 wxDateSpan *arg2 = 0 ;
26166 wxDateTime *result = 0 ;
26167 void *argp1 = 0 ;
26168 int res1 = 0 ;
26169 void *argp2 = 0 ;
26170 int res2 = 0 ;
26171 PyObject * obj0 = 0 ;
26172 PyObject * obj1 = 0 ;
26173 char * kwnames[] = {
26174 (char *) "self",(char *) "diff", NULL
26175 };
26176
26177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26179 if (!SWIG_IsOK(res1)) {
26180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26181 }
26182 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26183 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26184 if (!SWIG_IsOK(res2)) {
26185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26186 }
26187 if (!argp2) {
26188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26189 }
26190 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26191 {
26192 PyThreadState* __tstate = wxPyBeginAllowThreads();
26193 {
26194 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26195 result = (wxDateTime *) &_result_ref;
26196 }
26197 wxPyEndAllowThreads(__tstate);
26198 if (PyErr_Occurred()) SWIG_fail;
26199 }
26200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26201 return resultobj;
26202 fail:
26203 return NULL;
26204 }
26205
26206
26207 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26208 PyObject *resultobj = 0;
26209 wxDateTime *arg1 = (wxDateTime *) 0 ;
26210 wxDateTime *arg2 = 0 ;
26211 wxTimeSpan result;
26212 void *argp1 = 0 ;
26213 int res1 = 0 ;
26214 void *argp2 = 0 ;
26215 int res2 = 0 ;
26216 PyObject * obj0 = 0 ;
26217 PyObject * obj1 = 0 ;
26218 char * kwnames[] = {
26219 (char *) "self",(char *) "dt", NULL
26220 };
26221
26222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26224 if (!SWIG_IsOK(res1)) {
26225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26226 }
26227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26228 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26229 if (!SWIG_IsOK(res2)) {
26230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26231 }
26232 if (!argp2) {
26233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26234 }
26235 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26236 {
26237 PyThreadState* __tstate = wxPyBeginAllowThreads();
26238 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26250 PyObject *resultobj = 0;
26251 wxDateTime *arg1 = (wxDateTime *) 0 ;
26252 wxTimeSpan *arg2 = 0 ;
26253 wxDateTime *result = 0 ;
26254 void *argp1 = 0 ;
26255 int res1 = 0 ;
26256 void *argp2 = 0 ;
26257 int res2 = 0 ;
26258
26259 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26261 if (!SWIG_IsOK(res1)) {
26262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26263 }
26264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26265 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26266 if (!SWIG_IsOK(res2)) {
26267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26268 }
26269 if (!argp2) {
26270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26271 }
26272 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26273 {
26274 PyThreadState* __tstate = wxPyBeginAllowThreads();
26275 {
26276 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26277 result = (wxDateTime *) &_result_ref;
26278 }
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26290 PyObject *resultobj = 0;
26291 wxDateTime *arg1 = (wxDateTime *) 0 ;
26292 wxDateSpan *arg2 = 0 ;
26293 wxDateTime *result = 0 ;
26294 void *argp1 = 0 ;
26295 int res1 = 0 ;
26296 void *argp2 = 0 ;
26297 int res2 = 0 ;
26298
26299 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26301 if (!SWIG_IsOK(res1)) {
26302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26303 }
26304 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26305 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26306 if (!SWIG_IsOK(res2)) {
26307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26308 }
26309 if (!argp2) {
26310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26311 }
26312 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 {
26316 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26317 result = (wxDateTime *) &_result_ref;
26318 }
26319 wxPyEndAllowThreads(__tstate);
26320 if (PyErr_Occurred()) SWIG_fail;
26321 }
26322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26323 return resultobj;
26324 fail:
26325 return NULL;
26326 }
26327
26328
26329 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26330 int argc;
26331 PyObject *argv[3];
26332
26333 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26334 --argc;
26335 if (argc == 2) {
26336 int _v = 0;
26337 {
26338 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26339 _v = SWIG_CheckState(res);
26340 }
26341 if (!_v) goto check_1;
26342 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26343 }
26344 check_1:
26345
26346 if (argc == 2) {
26347 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26348 }
26349
26350 fail:
26351 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26352 return NULL;
26353 }
26354
26355
26356 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26357 PyObject *resultobj = 0;
26358 wxDateTime *arg1 = (wxDateTime *) 0 ;
26359 wxTimeSpan *arg2 = 0 ;
26360 wxDateTime *result = 0 ;
26361 void *argp1 = 0 ;
26362 int res1 = 0 ;
26363 void *argp2 = 0 ;
26364 int res2 = 0 ;
26365
26366 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26368 if (!SWIG_IsOK(res1)) {
26369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26370 }
26371 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26372 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26373 if (!SWIG_IsOK(res2)) {
26374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26375 }
26376 if (!argp2) {
26377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26378 }
26379 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26380 {
26381 PyThreadState* __tstate = wxPyBeginAllowThreads();
26382 {
26383 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26384 result = (wxDateTime *) &_result_ref;
26385 }
26386 wxPyEndAllowThreads(__tstate);
26387 if (PyErr_Occurred()) SWIG_fail;
26388 }
26389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26390 return resultobj;
26391 fail:
26392 return NULL;
26393 }
26394
26395
26396 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26397 PyObject *resultobj = 0;
26398 wxDateTime *arg1 = (wxDateTime *) 0 ;
26399 wxDateSpan *arg2 = 0 ;
26400 wxDateTime *result = 0 ;
26401 void *argp1 = 0 ;
26402 int res1 = 0 ;
26403 void *argp2 = 0 ;
26404 int res2 = 0 ;
26405
26406 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26408 if (!SWIG_IsOK(res1)) {
26409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26410 }
26411 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26412 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26413 if (!SWIG_IsOK(res2)) {
26414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26415 }
26416 if (!argp2) {
26417 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26418 }
26419 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 {
26423 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26424 result = (wxDateTime *) &_result_ref;
26425 }
26426 wxPyEndAllowThreads(__tstate);
26427 if (PyErr_Occurred()) SWIG_fail;
26428 }
26429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26430 return resultobj;
26431 fail:
26432 return NULL;
26433 }
26434
26435
26436 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26437 int argc;
26438 PyObject *argv[3];
26439
26440 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26441 --argc;
26442 if (argc == 2) {
26443 int _v = 0;
26444 {
26445 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26446 _v = SWIG_CheckState(res);
26447 }
26448 if (!_v) goto check_1;
26449 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26450 }
26451 check_1:
26452
26453 if (argc == 2) {
26454 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26455 }
26456
26457 fail:
26458 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26459 return NULL;
26460 }
26461
26462
26463 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26464 PyObject *resultobj = 0;
26465 wxDateTime *arg1 = (wxDateTime *) 0 ;
26466 wxTimeSpan *arg2 = 0 ;
26467 wxDateTime result;
26468 void *argp1 = 0 ;
26469 int res1 = 0 ;
26470 void *argp2 = 0 ;
26471 int res2 = 0 ;
26472
26473 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26475 if (!SWIG_IsOK(res1)) {
26476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26477 }
26478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26479 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26480 if (!SWIG_IsOK(res2)) {
26481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26482 }
26483 if (!argp2) {
26484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26485 }
26486 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26487 {
26488 PyThreadState* __tstate = wxPyBeginAllowThreads();
26489 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26490 wxPyEndAllowThreads(__tstate);
26491 if (PyErr_Occurred()) SWIG_fail;
26492 }
26493 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26494 return resultobj;
26495 fail:
26496 return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26501 PyObject *resultobj = 0;
26502 wxDateTime *arg1 = (wxDateTime *) 0 ;
26503 wxDateSpan *arg2 = 0 ;
26504 wxDateTime result;
26505 void *argp1 = 0 ;
26506 int res1 = 0 ;
26507 void *argp2 = 0 ;
26508 int res2 = 0 ;
26509
26510 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26512 if (!SWIG_IsOK(res1)) {
26513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26514 }
26515 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26516 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26517 if (!SWIG_IsOK(res2)) {
26518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26519 }
26520 if (!argp2) {
26521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26522 }
26523 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26524 {
26525 PyThreadState* __tstate = wxPyBeginAllowThreads();
26526 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26527 wxPyEndAllowThreads(__tstate);
26528 if (PyErr_Occurred()) SWIG_fail;
26529 }
26530 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26531 return resultobj;
26532 fail:
26533 return NULL;
26534 }
26535
26536
26537 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26538 int argc;
26539 PyObject *argv[3];
26540
26541 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26542 --argc;
26543 if (argc == 2) {
26544 int _v = 0;
26545 {
26546 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26547 _v = SWIG_CheckState(res);
26548 }
26549 if (!_v) goto check_1;
26550 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26551 }
26552 check_1:
26553
26554 if (argc == 2) {
26555 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26556 }
26557
26558 fail:
26559 Py_INCREF(Py_NotImplemented);
26560 return Py_NotImplemented;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26565 PyObject *resultobj = 0;
26566 wxDateTime *arg1 = (wxDateTime *) 0 ;
26567 wxDateTime *arg2 = 0 ;
26568 wxTimeSpan 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___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26578 }
26579 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26580 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26581 if (!SWIG_IsOK(res2)) {
26582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26583 }
26584 if (!argp2) {
26585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26586 }
26587 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26595 return resultobj;
26596 fail:
26597 return NULL;
26598 }
26599
26600
26601 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26602 PyObject *resultobj = 0;
26603 wxDateTime *arg1 = (wxDateTime *) 0 ;
26604 wxTimeSpan *arg2 = 0 ;
26605 wxDateTime result;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 void *argp2 = 0 ;
26609 int res2 = 0 ;
26610
26611 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26613 if (!SWIG_IsOK(res1)) {
26614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26615 }
26616 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26617 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26618 if (!SWIG_IsOK(res2)) {
26619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26620 }
26621 if (!argp2) {
26622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26623 }
26624 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26628 wxPyEndAllowThreads(__tstate);
26629 if (PyErr_Occurred()) SWIG_fail;
26630 }
26631 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26632 return resultobj;
26633 fail:
26634 return NULL;
26635 }
26636
26637
26638 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26639 PyObject *resultobj = 0;
26640 wxDateTime *arg1 = (wxDateTime *) 0 ;
26641 wxDateSpan *arg2 = 0 ;
26642 wxDateTime result;
26643 void *argp1 = 0 ;
26644 int res1 = 0 ;
26645 void *argp2 = 0 ;
26646 int res2 = 0 ;
26647
26648 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26650 if (!SWIG_IsOK(res1)) {
26651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26652 }
26653 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26654 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26655 if (!SWIG_IsOK(res2)) {
26656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26657 }
26658 if (!argp2) {
26659 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26660 }
26661 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26662 {
26663 PyThreadState* __tstate = wxPyBeginAllowThreads();
26664 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26665 wxPyEndAllowThreads(__tstate);
26666 if (PyErr_Occurred()) SWIG_fail;
26667 }
26668 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26669 return resultobj;
26670 fail:
26671 return NULL;
26672 }
26673
26674
26675 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26676 int argc;
26677 PyObject *argv[3];
26678
26679 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26680 --argc;
26681 if (argc == 2) {
26682 int _v = 0;
26683 {
26684 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26685 _v = SWIG_CheckState(res);
26686 }
26687 if (!_v) goto check_1;
26688 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26689 }
26690 check_1:
26691
26692 if (argc == 2) {
26693 int _v = 0;
26694 {
26695 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26696 _v = SWIG_CheckState(res);
26697 }
26698 if (!_v) goto check_2;
26699 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26700 }
26701 check_2:
26702
26703 if (argc == 2) {
26704 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26705 }
26706
26707 fail:
26708 Py_INCREF(Py_NotImplemented);
26709 return Py_NotImplemented;
26710 }
26711
26712
26713 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26714 PyObject *resultobj = 0;
26715 wxDateTime *arg1 = (wxDateTime *) 0 ;
26716 wxDateTime *arg2 = (wxDateTime *) 0 ;
26717 bool result;
26718 void *argp1 = 0 ;
26719 int res1 = 0 ;
26720 void *argp2 = 0 ;
26721 int res2 = 0 ;
26722 PyObject * obj0 = 0 ;
26723 PyObject * obj1 = 0 ;
26724 char * kwnames[] = {
26725 (char *) "self",(char *) "other", NULL
26726 };
26727
26728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26730 if (!SWIG_IsOK(res1)) {
26731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26732 }
26733 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26735 if (!SWIG_IsOK(res2)) {
26736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26737 }
26738 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26739 {
26740 PyThreadState* __tstate = wxPyBeginAllowThreads();
26741 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26742 wxPyEndAllowThreads(__tstate);
26743 if (PyErr_Occurred()) SWIG_fail;
26744 }
26745 {
26746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26747 }
26748 return resultobj;
26749 fail:
26750 return NULL;
26751 }
26752
26753
26754 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26755 PyObject *resultobj = 0;
26756 wxDateTime *arg1 = (wxDateTime *) 0 ;
26757 wxDateTime *arg2 = (wxDateTime *) 0 ;
26758 bool result;
26759 void *argp1 = 0 ;
26760 int res1 = 0 ;
26761 void *argp2 = 0 ;
26762 int res2 = 0 ;
26763 PyObject * obj0 = 0 ;
26764 PyObject * obj1 = 0 ;
26765 char * kwnames[] = {
26766 (char *) "self",(char *) "other", NULL
26767 };
26768
26769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26771 if (!SWIG_IsOK(res1)) {
26772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26773 }
26774 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26776 if (!SWIG_IsOK(res2)) {
26777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26778 }
26779 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 {
26787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26788 }
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26796 PyObject *resultobj = 0;
26797 wxDateTime *arg1 = (wxDateTime *) 0 ;
26798 wxDateTime *arg2 = (wxDateTime *) 0 ;
26799 bool result;
26800 void *argp1 = 0 ;
26801 int res1 = 0 ;
26802 void *argp2 = 0 ;
26803 int res2 = 0 ;
26804 PyObject * obj0 = 0 ;
26805 PyObject * obj1 = 0 ;
26806 char * kwnames[] = {
26807 (char *) "self",(char *) "other", NULL
26808 };
26809
26810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26812 if (!SWIG_IsOK(res1)) {
26813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26814 }
26815 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26817 if (!SWIG_IsOK(res2)) {
26818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26819 }
26820 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26821 {
26822 PyThreadState* __tstate = wxPyBeginAllowThreads();
26823 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26824 wxPyEndAllowThreads(__tstate);
26825 if (PyErr_Occurred()) SWIG_fail;
26826 }
26827 {
26828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26829 }
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26837 PyObject *resultobj = 0;
26838 wxDateTime *arg1 = (wxDateTime *) 0 ;
26839 wxDateTime *arg2 = (wxDateTime *) 0 ;
26840 bool result;
26841 void *argp1 = 0 ;
26842 int res1 = 0 ;
26843 void *argp2 = 0 ;
26844 int res2 = 0 ;
26845 PyObject * obj0 = 0 ;
26846 PyObject * obj1 = 0 ;
26847 char * kwnames[] = {
26848 (char *) "self",(char *) "other", NULL
26849 };
26850
26851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26853 if (!SWIG_IsOK(res1)) {
26854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26855 }
26856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26858 if (!SWIG_IsOK(res2)) {
26859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26860 }
26861 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26862 {
26863 PyThreadState* __tstate = wxPyBeginAllowThreads();
26864 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 {
26869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26870 }
26871 return resultobj;
26872 fail:
26873 return NULL;
26874 }
26875
26876
26877 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26878 PyObject *resultobj = 0;
26879 wxDateTime *arg1 = (wxDateTime *) 0 ;
26880 wxDateTime *arg2 = (wxDateTime *) 0 ;
26881 bool result;
26882 void *argp1 = 0 ;
26883 int res1 = 0 ;
26884 void *argp2 = 0 ;
26885 int res2 = 0 ;
26886 PyObject * obj0 = 0 ;
26887 PyObject * obj1 = 0 ;
26888 char * kwnames[] = {
26889 (char *) "self",(char *) "other", NULL
26890 };
26891
26892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26894 if (!SWIG_IsOK(res1)) {
26895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26896 }
26897 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26898 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26899 if (!SWIG_IsOK(res2)) {
26900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26901 }
26902 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26903 {
26904 PyThreadState* __tstate = wxPyBeginAllowThreads();
26905 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26906 wxPyEndAllowThreads(__tstate);
26907 if (PyErr_Occurred()) SWIG_fail;
26908 }
26909 {
26910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26911 }
26912 return resultobj;
26913 fail:
26914 return NULL;
26915 }
26916
26917
26918 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26919 PyObject *resultobj = 0;
26920 wxDateTime *arg1 = (wxDateTime *) 0 ;
26921 wxDateTime *arg2 = (wxDateTime *) 0 ;
26922 bool result;
26923 void *argp1 = 0 ;
26924 int res1 = 0 ;
26925 void *argp2 = 0 ;
26926 int res2 = 0 ;
26927 PyObject * obj0 = 0 ;
26928 PyObject * obj1 = 0 ;
26929 char * kwnames[] = {
26930 (char *) "self",(char *) "other", NULL
26931 };
26932
26933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26935 if (!SWIG_IsOK(res1)) {
26936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26937 }
26938 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26940 if (!SWIG_IsOK(res2)) {
26941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26942 }
26943 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26944 {
26945 PyThreadState* __tstate = wxPyBeginAllowThreads();
26946 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 {
26951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26952 }
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj = 0;
26961 wxDateTime *arg1 = (wxDateTime *) 0 ;
26962 wxString *arg2 = 0 ;
26963 int result;
26964 void *argp1 = 0 ;
26965 int res1 = 0 ;
26966 bool temp2 = false ;
26967 PyObject * obj0 = 0 ;
26968 PyObject * obj1 = 0 ;
26969 char * kwnames[] = {
26970 (char *) "self",(char *) "date", NULL
26971 };
26972
26973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26975 if (!SWIG_IsOK(res1)) {
26976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26977 }
26978 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26979 {
26980 arg2 = wxString_in_helper(obj1);
26981 if (arg2 == NULL) SWIG_fail;
26982 temp2 = true;
26983 }
26984 {
26985 PyThreadState* __tstate = wxPyBeginAllowThreads();
26986 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26987 wxPyEndAllowThreads(__tstate);
26988 if (PyErr_Occurred()) SWIG_fail;
26989 }
26990 resultobj = SWIG_From_int(static_cast< int >(result));
26991 {
26992 if (temp2)
26993 delete arg2;
26994 }
26995 return resultobj;
26996 fail:
26997 {
26998 if (temp2)
26999 delete arg2;
27000 }
27001 return NULL;
27002 }
27003
27004
27005 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27006 PyObject *resultobj = 0;
27007 wxDateTime *arg1 = (wxDateTime *) 0 ;
27008 wxString *arg2 = 0 ;
27009 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27010 wxString *arg3 = (wxString *) &arg3_defvalue ;
27011 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27012 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27013 int result;
27014 void *argp1 = 0 ;
27015 int res1 = 0 ;
27016 bool temp2 = false ;
27017 bool temp3 = false ;
27018 void *argp4 = 0 ;
27019 int res4 = 0 ;
27020 PyObject * obj0 = 0 ;
27021 PyObject * obj1 = 0 ;
27022 PyObject * obj2 = 0 ;
27023 PyObject * obj3 = 0 ;
27024 char * kwnames[] = {
27025 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27026 };
27027
27028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27030 if (!SWIG_IsOK(res1)) {
27031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27032 }
27033 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27034 {
27035 arg2 = wxString_in_helper(obj1);
27036 if (arg2 == NULL) SWIG_fail;
27037 temp2 = true;
27038 }
27039 if (obj2) {
27040 {
27041 arg3 = wxString_in_helper(obj2);
27042 if (arg3 == NULL) SWIG_fail;
27043 temp3 = true;
27044 }
27045 }
27046 if (obj3) {
27047 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
27048 if (!SWIG_IsOK(res4)) {
27049 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27050 }
27051 if (!argp4) {
27052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27053 }
27054 arg4 = reinterpret_cast< wxDateTime * >(argp4);
27055 }
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 resultobj = SWIG_From_int(static_cast< int >(result));
27063 {
27064 if (temp2)
27065 delete arg2;
27066 }
27067 {
27068 if (temp3)
27069 delete arg3;
27070 }
27071 return resultobj;
27072 fail:
27073 {
27074 if (temp2)
27075 delete arg2;
27076 }
27077 {
27078 if (temp3)
27079 delete arg3;
27080 }
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27086 PyObject *resultobj = 0;
27087 wxDateTime *arg1 = (wxDateTime *) 0 ;
27088 wxString *arg2 = 0 ;
27089 int result;
27090 void *argp1 = 0 ;
27091 int res1 = 0 ;
27092 bool temp2 = false ;
27093 PyObject * obj0 = 0 ;
27094 PyObject * obj1 = 0 ;
27095 char * kwnames[] = {
27096 (char *) "self",(char *) "datetime", NULL
27097 };
27098
27099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
27100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27101 if (!SWIG_IsOK(res1)) {
27102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27103 }
27104 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27105 {
27106 arg2 = wxString_in_helper(obj1);
27107 if (arg2 == NULL) SWIG_fail;
27108 temp2 = true;
27109 }
27110 {
27111 PyThreadState* __tstate = wxPyBeginAllowThreads();
27112 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
27113 wxPyEndAllowThreads(__tstate);
27114 if (PyErr_Occurred()) SWIG_fail;
27115 }
27116 resultobj = SWIG_From_int(static_cast< int >(result));
27117 {
27118 if (temp2)
27119 delete arg2;
27120 }
27121 return resultobj;
27122 fail:
27123 {
27124 if (temp2)
27125 delete arg2;
27126 }
27127 return NULL;
27128 }
27129
27130
27131 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27132 PyObject *resultobj = 0;
27133 wxDateTime *arg1 = (wxDateTime *) 0 ;
27134 wxString *arg2 = 0 ;
27135 int result;
27136 void *argp1 = 0 ;
27137 int res1 = 0 ;
27138 bool temp2 = false ;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 char * kwnames[] = {
27142 (char *) "self",(char *) "date", NULL
27143 };
27144
27145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27147 if (!SWIG_IsOK(res1)) {
27148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27149 }
27150 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27151 {
27152 arg2 = wxString_in_helper(obj1);
27153 if (arg2 == NULL) SWIG_fail;
27154 temp2 = true;
27155 }
27156 {
27157 PyThreadState* __tstate = wxPyBeginAllowThreads();
27158 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27159 wxPyEndAllowThreads(__tstate);
27160 if (PyErr_Occurred()) SWIG_fail;
27161 }
27162 resultobj = SWIG_From_int(static_cast< int >(result));
27163 {
27164 if (temp2)
27165 delete arg2;
27166 }
27167 return resultobj;
27168 fail:
27169 {
27170 if (temp2)
27171 delete arg2;
27172 }
27173 return NULL;
27174 }
27175
27176
27177 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27178 PyObject *resultobj = 0;
27179 wxDateTime *arg1 = (wxDateTime *) 0 ;
27180 wxString *arg2 = 0 ;
27181 int result;
27182 void *argp1 = 0 ;
27183 int res1 = 0 ;
27184 bool temp2 = false ;
27185 PyObject * obj0 = 0 ;
27186 PyObject * obj1 = 0 ;
27187 char * kwnames[] = {
27188 (char *) "self",(char *) "time", NULL
27189 };
27190
27191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27193 if (!SWIG_IsOK(res1)) {
27194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27195 }
27196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27197 {
27198 arg2 = wxString_in_helper(obj1);
27199 if (arg2 == NULL) SWIG_fail;
27200 temp2 = true;
27201 }
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27205 wxPyEndAllowThreads(__tstate);
27206 if (PyErr_Occurred()) SWIG_fail;
27207 }
27208 resultobj = SWIG_From_int(static_cast< int >(result));
27209 {
27210 if (temp2)
27211 delete arg2;
27212 }
27213 return resultobj;
27214 fail:
27215 {
27216 if (temp2)
27217 delete arg2;
27218 }
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj = 0;
27225 wxDateTime *arg1 = (wxDateTime *) 0 ;
27226 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27227 wxString *arg2 = (wxString *) &arg2_defvalue ;
27228 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27229 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27230 wxString result;
27231 void *argp1 = 0 ;
27232 int res1 = 0 ;
27233 bool temp2 = false ;
27234 bool temp3 = false ;
27235 PyObject * obj0 = 0 ;
27236 PyObject * obj1 = 0 ;
27237 PyObject * obj2 = 0 ;
27238 char * kwnames[] = {
27239 (char *) "self",(char *) "format",(char *) "tz", NULL
27240 };
27241
27242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27244 if (!SWIG_IsOK(res1)) {
27245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27246 }
27247 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27248 if (obj1) {
27249 {
27250 arg2 = wxString_in_helper(obj1);
27251 if (arg2 == NULL) SWIG_fail;
27252 temp2 = true;
27253 }
27254 }
27255 if (obj2) {
27256 {
27257 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27258 temp3 = true;
27259 }
27260 }
27261 {
27262 PyThreadState* __tstate = wxPyBeginAllowThreads();
27263 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27264 wxPyEndAllowThreads(__tstate);
27265 if (PyErr_Occurred()) SWIG_fail;
27266 }
27267 {
27268 #if wxUSE_UNICODE
27269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27270 #else
27271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27272 #endif
27273 }
27274 {
27275 if (temp2)
27276 delete arg2;
27277 }
27278 {
27279 if (temp3) delete arg3;
27280 }
27281 return resultobj;
27282 fail:
27283 {
27284 if (temp2)
27285 delete arg2;
27286 }
27287 {
27288 if (temp3) delete arg3;
27289 }
27290 return NULL;
27291 }
27292
27293
27294 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27295 PyObject *resultobj = 0;
27296 wxDateTime *arg1 = (wxDateTime *) 0 ;
27297 wxString result;
27298 void *argp1 = 0 ;
27299 int res1 = 0 ;
27300 PyObject *swig_obj[1] ;
27301
27302 if (!args) SWIG_fail;
27303 swig_obj[0] = args;
27304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27305 if (!SWIG_IsOK(res1)) {
27306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27307 }
27308 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27309 {
27310 PyThreadState* __tstate = wxPyBeginAllowThreads();
27311 result = ((wxDateTime const *)arg1)->FormatDate();
27312 wxPyEndAllowThreads(__tstate);
27313 if (PyErr_Occurred()) SWIG_fail;
27314 }
27315 {
27316 #if wxUSE_UNICODE
27317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27318 #else
27319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27320 #endif
27321 }
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27329 PyObject *resultobj = 0;
27330 wxDateTime *arg1 = (wxDateTime *) 0 ;
27331 wxString result;
27332 void *argp1 = 0 ;
27333 int res1 = 0 ;
27334 PyObject *swig_obj[1] ;
27335
27336 if (!args) SWIG_fail;
27337 swig_obj[0] = args;
27338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27339 if (!SWIG_IsOK(res1)) {
27340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27341 }
27342 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = ((wxDateTime const *)arg1)->FormatTime();
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 {
27350 #if wxUSE_UNICODE
27351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27352 #else
27353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27354 #endif
27355 }
27356 return resultobj;
27357 fail:
27358 return NULL;
27359 }
27360
27361
27362 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27363 PyObject *resultobj = 0;
27364 wxDateTime *arg1 = (wxDateTime *) 0 ;
27365 wxString result;
27366 void *argp1 = 0 ;
27367 int res1 = 0 ;
27368 PyObject *swig_obj[1] ;
27369
27370 if (!args) SWIG_fail;
27371 swig_obj[0] = args;
27372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27373 if (!SWIG_IsOK(res1)) {
27374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27375 }
27376 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27377 {
27378 PyThreadState* __tstate = wxPyBeginAllowThreads();
27379 result = ((wxDateTime const *)arg1)->FormatISODate();
27380 wxPyEndAllowThreads(__tstate);
27381 if (PyErr_Occurred()) SWIG_fail;
27382 }
27383 {
27384 #if wxUSE_UNICODE
27385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27386 #else
27387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27388 #endif
27389 }
27390 return resultobj;
27391 fail:
27392 return NULL;
27393 }
27394
27395
27396 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27397 PyObject *resultobj = 0;
27398 wxDateTime *arg1 = (wxDateTime *) 0 ;
27399 wxString result;
27400 void *argp1 = 0 ;
27401 int res1 = 0 ;
27402 PyObject *swig_obj[1] ;
27403
27404 if (!args) SWIG_fail;
27405 swig_obj[0] = args;
27406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27407 if (!SWIG_IsOK(res1)) {
27408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27409 }
27410 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 result = ((wxDateTime const *)arg1)->FormatISOTime();
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 {
27418 #if wxUSE_UNICODE
27419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27420 #else
27421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27422 #endif
27423 }
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27431 PyObject *obj;
27432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27433 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27434 return SWIG_Py_Void();
27435 }
27436
27437 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27438 return SWIG_Python_InitShadowInstance(args);
27439 }
27440
27441 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27442 PyObject *resultobj = 0;
27443 long arg1 ;
27444 wxTimeSpan result;
27445 long val1 ;
27446 int ecode1 = 0 ;
27447 PyObject * obj0 = 0 ;
27448 char * kwnames[] = {
27449 (char *) "ms", NULL
27450 };
27451
27452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27453 ecode1 = SWIG_AsVal_long(obj0, &val1);
27454 if (!SWIG_IsOK(ecode1)) {
27455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27456 }
27457 arg1 = static_cast< long >(val1);
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = wxTimeSpan::Milliseconds(arg1);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27472 PyObject *resultobj = 0;
27473 wxTimeSpan result;
27474
27475 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 result = wxTimeSpan::Millisecond();
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27490 PyObject *resultobj = 0;
27491 long arg1 ;
27492 wxTimeSpan result;
27493 long val1 ;
27494 int ecode1 = 0 ;
27495 PyObject * obj0 = 0 ;
27496 char * kwnames[] = {
27497 (char *) "sec", NULL
27498 };
27499
27500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27501 ecode1 = SWIG_AsVal_long(obj0, &val1);
27502 if (!SWIG_IsOK(ecode1)) {
27503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27504 }
27505 arg1 = static_cast< long >(val1);
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = wxTimeSpan::Seconds(arg1);
27509 wxPyEndAllowThreads(__tstate);
27510 if (PyErr_Occurred()) SWIG_fail;
27511 }
27512 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27513 return resultobj;
27514 fail:
27515 return NULL;
27516 }
27517
27518
27519 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27520 PyObject *resultobj = 0;
27521 wxTimeSpan result;
27522
27523 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27524 {
27525 PyThreadState* __tstate = wxPyBeginAllowThreads();
27526 result = wxTimeSpan::Second();
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27538 PyObject *resultobj = 0;
27539 long arg1 ;
27540 wxTimeSpan result;
27541 long val1 ;
27542 int ecode1 = 0 ;
27543 PyObject * obj0 = 0 ;
27544 char * kwnames[] = {
27545 (char *) "min", NULL
27546 };
27547
27548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27549 ecode1 = SWIG_AsVal_long(obj0, &val1);
27550 if (!SWIG_IsOK(ecode1)) {
27551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27552 }
27553 arg1 = static_cast< long >(val1);
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = wxTimeSpan::Minutes(arg1);
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *resultobj = 0;
27569 wxTimeSpan result;
27570
27571 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27572 {
27573 PyThreadState* __tstate = wxPyBeginAllowThreads();
27574 result = wxTimeSpan::Minute();
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27586 PyObject *resultobj = 0;
27587 long arg1 ;
27588 wxTimeSpan result;
27589 long val1 ;
27590 int ecode1 = 0 ;
27591 PyObject * obj0 = 0 ;
27592 char * kwnames[] = {
27593 (char *) "hours", NULL
27594 };
27595
27596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27597 ecode1 = SWIG_AsVal_long(obj0, &val1);
27598 if (!SWIG_IsOK(ecode1)) {
27599 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27600 }
27601 arg1 = static_cast< long >(val1);
27602 {
27603 PyThreadState* __tstate = wxPyBeginAllowThreads();
27604 result = wxTimeSpan::Hours(arg1);
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27609 return resultobj;
27610 fail:
27611 return NULL;
27612 }
27613
27614
27615 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27616 PyObject *resultobj = 0;
27617 wxTimeSpan result;
27618
27619 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 result = wxTimeSpan::Hour();
27623 wxPyEndAllowThreads(__tstate);
27624 if (PyErr_Occurred()) SWIG_fail;
27625 }
27626 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27634 PyObject *resultobj = 0;
27635 long arg1 ;
27636 wxTimeSpan result;
27637 long val1 ;
27638 int ecode1 = 0 ;
27639 PyObject * obj0 = 0 ;
27640 char * kwnames[] = {
27641 (char *) "days", NULL
27642 };
27643
27644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27645 ecode1 = SWIG_AsVal_long(obj0, &val1);
27646 if (!SWIG_IsOK(ecode1)) {
27647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27648 }
27649 arg1 = static_cast< long >(val1);
27650 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 result = wxTimeSpan::Days(arg1);
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27664 PyObject *resultobj = 0;
27665 wxTimeSpan result;
27666
27667 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 result = wxTimeSpan::Day();
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27682 PyObject *resultobj = 0;
27683 long arg1 ;
27684 wxTimeSpan result;
27685 long val1 ;
27686 int ecode1 = 0 ;
27687 PyObject * obj0 = 0 ;
27688 char * kwnames[] = {
27689 (char *) "days", NULL
27690 };
27691
27692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27693 ecode1 = SWIG_AsVal_long(obj0, &val1);
27694 if (!SWIG_IsOK(ecode1)) {
27695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27696 }
27697 arg1 = static_cast< long >(val1);
27698 {
27699 PyThreadState* __tstate = wxPyBeginAllowThreads();
27700 result = wxTimeSpan::Weeks(arg1);
27701 wxPyEndAllowThreads(__tstate);
27702 if (PyErr_Occurred()) SWIG_fail;
27703 }
27704 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27712 PyObject *resultobj = 0;
27713 wxTimeSpan result;
27714
27715 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = wxTimeSpan::Week();
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj = 0;
27731 long arg1 = (long) 0 ;
27732 long arg2 = (long) 0 ;
27733 long arg3 = (long) 0 ;
27734 long arg4 = (long) 0 ;
27735 wxTimeSpan *result = 0 ;
27736 long val1 ;
27737 int ecode1 = 0 ;
27738 long val2 ;
27739 int ecode2 = 0 ;
27740 long val3 ;
27741 int ecode3 = 0 ;
27742 long val4 ;
27743 int ecode4 = 0 ;
27744 PyObject * obj0 = 0 ;
27745 PyObject * obj1 = 0 ;
27746 PyObject * obj2 = 0 ;
27747 PyObject * obj3 = 0 ;
27748 char * kwnames[] = {
27749 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27750 };
27751
27752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27753 if (obj0) {
27754 ecode1 = SWIG_AsVal_long(obj0, &val1);
27755 if (!SWIG_IsOK(ecode1)) {
27756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27757 }
27758 arg1 = static_cast< long >(val1);
27759 }
27760 if (obj1) {
27761 ecode2 = SWIG_AsVal_long(obj1, &val2);
27762 if (!SWIG_IsOK(ecode2)) {
27763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27764 }
27765 arg2 = static_cast< long >(val2);
27766 }
27767 if (obj2) {
27768 ecode3 = SWIG_AsVal_long(obj2, &val3);
27769 if (!SWIG_IsOK(ecode3)) {
27770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27771 }
27772 arg3 = static_cast< long >(val3);
27773 }
27774 if (obj3) {
27775 ecode4 = SWIG_AsVal_long(obj3, &val4);
27776 if (!SWIG_IsOK(ecode4)) {
27777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27778 }
27779 arg4 = static_cast< long >(val4);
27780 }
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27784 wxPyEndAllowThreads(__tstate);
27785 if (PyErr_Occurred()) SWIG_fail;
27786 }
27787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27788 return resultobj;
27789 fail:
27790 return NULL;
27791 }
27792
27793
27794 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27795 PyObject *resultobj = 0;
27796 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27797 void *argp1 = 0 ;
27798 int res1 = 0 ;
27799 PyObject *swig_obj[1] ;
27800
27801 if (!args) SWIG_fail;
27802 swig_obj[0] = args;
27803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27804 if (!SWIG_IsOK(res1)) {
27805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27806 }
27807 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27808 {
27809 PyThreadState* __tstate = wxPyBeginAllowThreads();
27810 delete arg1;
27811
27812 wxPyEndAllowThreads(__tstate);
27813 if (PyErr_Occurred()) SWIG_fail;
27814 }
27815 resultobj = SWIG_Py_Void();
27816 return resultobj;
27817 fail:
27818 return NULL;
27819 }
27820
27821
27822 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27823 PyObject *resultobj = 0;
27824 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27825 wxTimeSpan *arg2 = 0 ;
27826 wxTimeSpan *result = 0 ;
27827 void *argp1 = 0 ;
27828 int res1 = 0 ;
27829 void *argp2 = 0 ;
27830 int res2 = 0 ;
27831 PyObject * obj0 = 0 ;
27832 PyObject * obj1 = 0 ;
27833 char * kwnames[] = {
27834 (char *) "self",(char *) "diff", NULL
27835 };
27836
27837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27839 if (!SWIG_IsOK(res1)) {
27840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27841 }
27842 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27843 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27844 if (!SWIG_IsOK(res2)) {
27845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27846 }
27847 if (!argp2) {
27848 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27849 }
27850 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 {
27854 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27855 result = (wxTimeSpan *) &_result_ref;
27856 }
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj = 0;
27869 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27870 wxTimeSpan *arg2 = 0 ;
27871 wxTimeSpan *result = 0 ;
27872 void *argp1 = 0 ;
27873 int res1 = 0 ;
27874 void *argp2 = 0 ;
27875 int res2 = 0 ;
27876 PyObject * obj0 = 0 ;
27877 PyObject * obj1 = 0 ;
27878 char * kwnames[] = {
27879 (char *) "self",(char *) "diff", NULL
27880 };
27881
27882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27884 if (!SWIG_IsOK(res1)) {
27885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27886 }
27887 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27888 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27889 if (!SWIG_IsOK(res2)) {
27890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27891 }
27892 if (!argp2) {
27893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27894 }
27895 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 {
27899 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27900 result = (wxTimeSpan *) &_result_ref;
27901 }
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj = 0;
27914 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27915 int arg2 ;
27916 wxTimeSpan *result = 0 ;
27917 void *argp1 = 0 ;
27918 int res1 = 0 ;
27919 int val2 ;
27920 int ecode2 = 0 ;
27921 PyObject * obj0 = 0 ;
27922 PyObject * obj1 = 0 ;
27923 char * kwnames[] = {
27924 (char *) "self",(char *) "n", NULL
27925 };
27926
27927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27929 if (!SWIG_IsOK(res1)) {
27930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27931 }
27932 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27933 ecode2 = SWIG_AsVal_int(obj1, &val2);
27934 if (!SWIG_IsOK(ecode2)) {
27935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27936 }
27937 arg2 = static_cast< int >(val2);
27938 {
27939 PyThreadState* __tstate = wxPyBeginAllowThreads();
27940 {
27941 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27942 result = (wxTimeSpan *) &_result_ref;
27943 }
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27955 PyObject *resultobj = 0;
27956 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27957 wxTimeSpan *result = 0 ;
27958 void *argp1 = 0 ;
27959 int res1 = 0 ;
27960 PyObject *swig_obj[1] ;
27961
27962 if (!args) SWIG_fail;
27963 swig_obj[0] = args;
27964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27965 if (!SWIG_IsOK(res1)) {
27966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27967 }
27968 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 {
27972 wxTimeSpan &_result_ref = (arg1)->Neg();
27973 result = (wxTimeSpan *) &_result_ref;
27974 }
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27986 PyObject *resultobj = 0;
27987 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27988 wxTimeSpan result;
27989 void *argp1 = 0 ;
27990 int res1 = 0 ;
27991 PyObject *swig_obj[1] ;
27992
27993 if (!args) SWIG_fail;
27994 swig_obj[0] = args;
27995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27996 if (!SWIG_IsOK(res1)) {
27997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27998 }
27999 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 result = ((wxTimeSpan const *)arg1)->Abs();
28003 wxPyEndAllowThreads(__tstate);
28004 if (PyErr_Occurred()) SWIG_fail;
28005 }
28006 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28007 return resultobj;
28008 fail:
28009 return NULL;
28010 }
28011
28012
28013 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28014 PyObject *resultobj = 0;
28015 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28016 wxTimeSpan *arg2 = 0 ;
28017 wxTimeSpan *result = 0 ;
28018 void *argp1 = 0 ;
28019 int res1 = 0 ;
28020 void *argp2 = 0 ;
28021 int res2 = 0 ;
28022 PyObject * obj0 = 0 ;
28023 PyObject * obj1 = 0 ;
28024 char * kwnames[] = {
28025 (char *) "self",(char *) "diff", NULL
28026 };
28027
28028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28030 if (!SWIG_IsOK(res1)) {
28031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28032 }
28033 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28034 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28035 if (!SWIG_IsOK(res2)) {
28036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28037 }
28038 if (!argp2) {
28039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28040 }
28041 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28042 {
28043 PyThreadState* __tstate = wxPyBeginAllowThreads();
28044 {
28045 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
28046 result = (wxTimeSpan *) &_result_ref;
28047 }
28048 wxPyEndAllowThreads(__tstate);
28049 if (PyErr_Occurred()) SWIG_fail;
28050 }
28051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj = 0;
28060 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28061 wxTimeSpan *arg2 = 0 ;
28062 wxTimeSpan *result = 0 ;
28063 void *argp1 = 0 ;
28064 int res1 = 0 ;
28065 void *argp2 = 0 ;
28066 int res2 = 0 ;
28067 PyObject * obj0 = 0 ;
28068 PyObject * obj1 = 0 ;
28069 char * kwnames[] = {
28070 (char *) "self",(char *) "diff", NULL
28071 };
28072
28073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
28074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28075 if (!SWIG_IsOK(res1)) {
28076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28077 }
28078 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28080 if (!SWIG_IsOK(res2)) {
28081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28082 }
28083 if (!argp2) {
28084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28085 }
28086 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28087 {
28088 PyThreadState* __tstate = wxPyBeginAllowThreads();
28089 {
28090 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
28091 result = (wxTimeSpan *) &_result_ref;
28092 }
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28106 int arg2 ;
28107 wxTimeSpan *result = 0 ;
28108 void *argp1 = 0 ;
28109 int res1 = 0 ;
28110 int val2 ;
28111 int ecode2 = 0 ;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char * kwnames[] = {
28115 (char *) "self",(char *) "n", NULL
28116 };
28117
28118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28120 if (!SWIG_IsOK(res1)) {
28121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28122 }
28123 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28124 ecode2 = SWIG_AsVal_int(obj1, &val2);
28125 if (!SWIG_IsOK(ecode2)) {
28126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28127 }
28128 arg2 = static_cast< int >(val2);
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 {
28132 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28133 result = (wxTimeSpan *) &_result_ref;
28134 }
28135 wxPyEndAllowThreads(__tstate);
28136 if (PyErr_Occurred()) SWIG_fail;
28137 }
28138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28139 return resultobj;
28140 fail:
28141 return NULL;
28142 }
28143
28144
28145 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28146 PyObject *resultobj = 0;
28147 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28148 wxTimeSpan *result = 0 ;
28149 void *argp1 = 0 ;
28150 int res1 = 0 ;
28151 PyObject *swig_obj[1] ;
28152
28153 if (!args) SWIG_fail;
28154 swig_obj[0] = args;
28155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28156 if (!SWIG_IsOK(res1)) {
28157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28158 }
28159 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28160 {
28161 PyThreadState* __tstate = wxPyBeginAllowThreads();
28162 {
28163 wxTimeSpan &_result_ref = (arg1)->operator -();
28164 result = (wxTimeSpan *) &_result_ref;
28165 }
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj = 0;
28178 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28179 wxTimeSpan *arg2 = 0 ;
28180 wxTimeSpan result;
28181 void *argp1 = 0 ;
28182 int res1 = 0 ;
28183 void *argp2 = 0 ;
28184 int res2 = 0 ;
28185 PyObject * obj0 = 0 ;
28186 PyObject * obj1 = 0 ;
28187 char * kwnames[] = {
28188 (char *) "self",(char *) "other", NULL
28189 };
28190
28191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28193 if (!SWIG_IsOK(res1)) {
28194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28195 }
28196 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28197 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28198 if (!SWIG_IsOK(res2)) {
28199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28200 }
28201 if (!argp2) {
28202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28203 }
28204 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28205 {
28206 PyThreadState* __tstate = wxPyBeginAllowThreads();
28207 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28208 wxPyEndAllowThreads(__tstate);
28209 if (PyErr_Occurred()) SWIG_fail;
28210 }
28211 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28212 return resultobj;
28213 fail:
28214 return NULL;
28215 }
28216
28217
28218 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28219 PyObject *resultobj = 0;
28220 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28221 wxTimeSpan *arg2 = 0 ;
28222 wxTimeSpan result;
28223 void *argp1 = 0 ;
28224 int res1 = 0 ;
28225 void *argp2 = 0 ;
28226 int res2 = 0 ;
28227 PyObject * obj0 = 0 ;
28228 PyObject * obj1 = 0 ;
28229 char * kwnames[] = {
28230 (char *) "self",(char *) "other", NULL
28231 };
28232
28233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28235 if (!SWIG_IsOK(res1)) {
28236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28237 }
28238 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28239 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28240 if (!SWIG_IsOK(res2)) {
28241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28242 }
28243 if (!argp2) {
28244 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28245 }
28246 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28254 return resultobj;
28255 fail:
28256 return NULL;
28257 }
28258
28259
28260 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28261 PyObject *resultobj = 0;
28262 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28263 int arg2 ;
28264 wxTimeSpan result;
28265 void *argp1 = 0 ;
28266 int res1 = 0 ;
28267 int val2 ;
28268 int ecode2 = 0 ;
28269 PyObject * obj0 = 0 ;
28270 PyObject * obj1 = 0 ;
28271 char * kwnames[] = {
28272 (char *) "self",(char *) "n", NULL
28273 };
28274
28275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28277 if (!SWIG_IsOK(res1)) {
28278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28279 }
28280 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28281 ecode2 = SWIG_AsVal_int(obj1, &val2);
28282 if (!SWIG_IsOK(ecode2)) {
28283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28284 }
28285 arg2 = static_cast< int >(val2);
28286 {
28287 PyThreadState* __tstate = wxPyBeginAllowThreads();
28288 result = wxTimeSpan___mul__(arg1,arg2);
28289 wxPyEndAllowThreads(__tstate);
28290 if (PyErr_Occurred()) SWIG_fail;
28291 }
28292 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28293 return resultobj;
28294 fail:
28295 return NULL;
28296 }
28297
28298
28299 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28300 PyObject *resultobj = 0;
28301 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28302 int arg2 ;
28303 wxTimeSpan result;
28304 void *argp1 = 0 ;
28305 int res1 = 0 ;
28306 int val2 ;
28307 int ecode2 = 0 ;
28308 PyObject * obj0 = 0 ;
28309 PyObject * obj1 = 0 ;
28310 char * kwnames[] = {
28311 (char *) "self",(char *) "n", NULL
28312 };
28313
28314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28316 if (!SWIG_IsOK(res1)) {
28317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28318 }
28319 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28320 ecode2 = SWIG_AsVal_int(obj1, &val2);
28321 if (!SWIG_IsOK(ecode2)) {
28322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28323 }
28324 arg2 = static_cast< int >(val2);
28325 {
28326 PyThreadState* __tstate = wxPyBeginAllowThreads();
28327 result = wxTimeSpan___rmul__(arg1,arg2);
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28332 return resultobj;
28333 fail:
28334 return NULL;
28335 }
28336
28337
28338 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28339 PyObject *resultobj = 0;
28340 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28341 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28342 bool result;
28343 void *argp1 = 0 ;
28344 int res1 = 0 ;
28345 void *argp2 = 0 ;
28346 int res2 = 0 ;
28347 PyObject * obj0 = 0 ;
28348 PyObject * obj1 = 0 ;
28349 char * kwnames[] = {
28350 (char *) "self",(char *) "other", NULL
28351 };
28352
28353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28355 if (!SWIG_IsOK(res1)) {
28356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28357 }
28358 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28360 if (!SWIG_IsOK(res2)) {
28361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28362 }
28363 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28367 wxPyEndAllowThreads(__tstate);
28368 if (PyErr_Occurred()) SWIG_fail;
28369 }
28370 {
28371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28372 }
28373 return resultobj;
28374 fail:
28375 return NULL;
28376 }
28377
28378
28379 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28380 PyObject *resultobj = 0;
28381 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28382 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28383 bool result;
28384 void *argp1 = 0 ;
28385 int res1 = 0 ;
28386 void *argp2 = 0 ;
28387 int res2 = 0 ;
28388 PyObject * obj0 = 0 ;
28389 PyObject * obj1 = 0 ;
28390 char * kwnames[] = {
28391 (char *) "self",(char *) "other", NULL
28392 };
28393
28394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28396 if (!SWIG_IsOK(res1)) {
28397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28398 }
28399 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28401 if (!SWIG_IsOK(res2)) {
28402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28403 }
28404 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 {
28412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28413 }
28414 return resultobj;
28415 fail:
28416 return NULL;
28417 }
28418
28419
28420 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28421 PyObject *resultobj = 0;
28422 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28423 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28424 bool result;
28425 void *argp1 = 0 ;
28426 int res1 = 0 ;
28427 void *argp2 = 0 ;
28428 int res2 = 0 ;
28429 PyObject * obj0 = 0 ;
28430 PyObject * obj1 = 0 ;
28431 char * kwnames[] = {
28432 (char *) "self",(char *) "other", NULL
28433 };
28434
28435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28437 if (!SWIG_IsOK(res1)) {
28438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28439 }
28440 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28442 if (!SWIG_IsOK(res2)) {
28443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28444 }
28445 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28449 wxPyEndAllowThreads(__tstate);
28450 if (PyErr_Occurred()) SWIG_fail;
28451 }
28452 {
28453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28454 }
28455 return resultobj;
28456 fail:
28457 return NULL;
28458 }
28459
28460
28461 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28462 PyObject *resultobj = 0;
28463 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28464 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28465 bool result;
28466 void *argp1 = 0 ;
28467 int res1 = 0 ;
28468 void *argp2 = 0 ;
28469 int res2 = 0 ;
28470 PyObject * obj0 = 0 ;
28471 PyObject * obj1 = 0 ;
28472 char * kwnames[] = {
28473 (char *) "self",(char *) "other", NULL
28474 };
28475
28476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28478 if (!SWIG_IsOK(res1)) {
28479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28480 }
28481 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28483 if (!SWIG_IsOK(res2)) {
28484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28485 }
28486 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28487 {
28488 PyThreadState* __tstate = wxPyBeginAllowThreads();
28489 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28490 wxPyEndAllowThreads(__tstate);
28491 if (PyErr_Occurred()) SWIG_fail;
28492 }
28493 {
28494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28495 }
28496 return resultobj;
28497 fail:
28498 return NULL;
28499 }
28500
28501
28502 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28503 PyObject *resultobj = 0;
28504 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28505 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28506 bool result;
28507 void *argp1 = 0 ;
28508 int res1 = 0 ;
28509 void *argp2 = 0 ;
28510 int res2 = 0 ;
28511 PyObject * obj0 = 0 ;
28512 PyObject * obj1 = 0 ;
28513 char * kwnames[] = {
28514 (char *) "self",(char *) "other", NULL
28515 };
28516
28517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28519 if (!SWIG_IsOK(res1)) {
28520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28521 }
28522 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28524 if (!SWIG_IsOK(res2)) {
28525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28526 }
28527 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 {
28535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28536 }
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28544 PyObject *resultobj = 0;
28545 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28546 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28547 bool result;
28548 void *argp1 = 0 ;
28549 int res1 = 0 ;
28550 void *argp2 = 0 ;
28551 int res2 = 0 ;
28552 PyObject * obj0 = 0 ;
28553 PyObject * obj1 = 0 ;
28554 char * kwnames[] = {
28555 (char *) "self",(char *) "other", NULL
28556 };
28557
28558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28560 if (!SWIG_IsOK(res1)) {
28561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28562 }
28563 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28564 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28565 if (!SWIG_IsOK(res2)) {
28566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28567 }
28568 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28569 {
28570 PyThreadState* __tstate = wxPyBeginAllowThreads();
28571 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28572 wxPyEndAllowThreads(__tstate);
28573 if (PyErr_Occurred()) SWIG_fail;
28574 }
28575 {
28576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28577 }
28578 return resultobj;
28579 fail:
28580 return NULL;
28581 }
28582
28583
28584 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28585 PyObject *resultobj = 0;
28586 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28587 bool result;
28588 void *argp1 = 0 ;
28589 int res1 = 0 ;
28590 PyObject *swig_obj[1] ;
28591
28592 if (!args) SWIG_fail;
28593 swig_obj[0] = args;
28594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28595 if (!SWIG_IsOK(res1)) {
28596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28597 }
28598 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 {
28606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28607 }
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28615 PyObject *resultobj = 0;
28616 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28617 bool result;
28618 void *argp1 = 0 ;
28619 int res1 = 0 ;
28620 PyObject *swig_obj[1] ;
28621
28622 if (!args) SWIG_fail;
28623 swig_obj[0] = args;
28624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28625 if (!SWIG_IsOK(res1)) {
28626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28627 }
28628 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 {
28636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28637 }
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28647 bool result;
28648 void *argp1 = 0 ;
28649 int res1 = 0 ;
28650 PyObject *swig_obj[1] ;
28651
28652 if (!args) SWIG_fail;
28653 swig_obj[0] = args;
28654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28657 }
28658 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 {
28666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28667 }
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28675 PyObject *resultobj = 0;
28676 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28677 wxTimeSpan *arg2 = 0 ;
28678 bool result;
28679 void *argp1 = 0 ;
28680 int res1 = 0 ;
28681 void *argp2 = 0 ;
28682 int res2 = 0 ;
28683 PyObject * obj0 = 0 ;
28684 PyObject * obj1 = 0 ;
28685 char * kwnames[] = {
28686 (char *) "self",(char *) "ts", NULL
28687 };
28688
28689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28691 if (!SWIG_IsOK(res1)) {
28692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28693 }
28694 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28696 if (!SWIG_IsOK(res2)) {
28697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28698 }
28699 if (!argp2) {
28700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28701 }
28702 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 {
28710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28711 }
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28719 PyObject *resultobj = 0;
28720 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28721 wxTimeSpan *arg2 = 0 ;
28722 bool result;
28723 void *argp1 = 0 ;
28724 int res1 = 0 ;
28725 void *argp2 = 0 ;
28726 int res2 = 0 ;
28727 PyObject * obj0 = 0 ;
28728 PyObject * obj1 = 0 ;
28729 char * kwnames[] = {
28730 (char *) "self",(char *) "ts", NULL
28731 };
28732
28733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28735 if (!SWIG_IsOK(res1)) {
28736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28737 }
28738 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28740 if (!SWIG_IsOK(res2)) {
28741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28742 }
28743 if (!argp2) {
28744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28745 }
28746 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28747 {
28748 PyThreadState* __tstate = wxPyBeginAllowThreads();
28749 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28750 wxPyEndAllowThreads(__tstate);
28751 if (PyErr_Occurred()) SWIG_fail;
28752 }
28753 {
28754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28755 }
28756 return resultobj;
28757 fail:
28758 return NULL;
28759 }
28760
28761
28762 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28763 PyObject *resultobj = 0;
28764 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28765 wxTimeSpan *arg2 = 0 ;
28766 bool result;
28767 void *argp1 = 0 ;
28768 int res1 = 0 ;
28769 void *argp2 = 0 ;
28770 int res2 = 0 ;
28771 PyObject * obj0 = 0 ;
28772 PyObject * obj1 = 0 ;
28773 char * kwnames[] = {
28774 (char *) "self",(char *) "t", NULL
28775 };
28776
28777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28779 if (!SWIG_IsOK(res1)) {
28780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28781 }
28782 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28784 if (!SWIG_IsOK(res2)) {
28785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28786 }
28787 if (!argp2) {
28788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28789 }
28790 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28794 wxPyEndAllowThreads(__tstate);
28795 if (PyErr_Occurred()) SWIG_fail;
28796 }
28797 {
28798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28799 }
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28807 PyObject *resultobj = 0;
28808 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28809 int result;
28810 void *argp1 = 0 ;
28811 int res1 = 0 ;
28812 PyObject *swig_obj[1] ;
28813
28814 if (!args) SWIG_fail;
28815 swig_obj[0] = args;
28816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28817 if (!SWIG_IsOK(res1)) {
28818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28819 }
28820 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 resultobj = SWIG_From_int(static_cast< int >(result));
28828 return resultobj;
28829 fail:
28830 return NULL;
28831 }
28832
28833
28834 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28835 PyObject *resultobj = 0;
28836 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28837 int result;
28838 void *argp1 = 0 ;
28839 int res1 = 0 ;
28840 PyObject *swig_obj[1] ;
28841
28842 if (!args) SWIG_fail;
28843 swig_obj[0] = args;
28844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28845 if (!SWIG_IsOK(res1)) {
28846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28847 }
28848 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 resultobj = SWIG_From_int(static_cast< int >(result));
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28863 PyObject *resultobj = 0;
28864 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28865 int result;
28866 void *argp1 = 0 ;
28867 int res1 = 0 ;
28868 PyObject *swig_obj[1] ;
28869
28870 if (!args) SWIG_fail;
28871 swig_obj[0] = args;
28872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28875 }
28876 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_From_int(static_cast< int >(result));
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28891 PyObject *resultobj = 0;
28892 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28893 int result;
28894 void *argp1 = 0 ;
28895 int res1 = 0 ;
28896 PyObject *swig_obj[1] ;
28897
28898 if (!args) SWIG_fail;
28899 swig_obj[0] = args;
28900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28901 if (!SWIG_IsOK(res1)) {
28902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28903 }
28904 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28908 wxPyEndAllowThreads(__tstate);
28909 if (PyErr_Occurred()) SWIG_fail;
28910 }
28911 resultobj = SWIG_From_int(static_cast< int >(result));
28912 return resultobj;
28913 fail:
28914 return NULL;
28915 }
28916
28917
28918 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28919 PyObject *resultobj = 0;
28920 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28921 wxLongLong result;
28922 void *argp1 = 0 ;
28923 int res1 = 0 ;
28924 PyObject *swig_obj[1] ;
28925
28926 if (!args) SWIG_fail;
28927 swig_obj[0] = args;
28928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28929 if (!SWIG_IsOK(res1)) {
28930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28931 }
28932 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28933 {
28934 PyThreadState* __tstate = wxPyBeginAllowThreads();
28935 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28936 wxPyEndAllowThreads(__tstate);
28937 if (PyErr_Occurred()) SWIG_fail;
28938 }
28939 {
28940 PyObject *hi, *lo, *shifter, *shifted;
28941 hi = PyLong_FromLong( (&result)->GetHi() );
28942 lo = PyLong_FromLong( (&result)->GetLo() );
28943 shifter = PyLong_FromLong(32);
28944 shifted = PyNumber_Lshift(hi, shifter);
28945 resultobj = PyNumber_Or(shifted, lo);
28946 Py_DECREF(hi);
28947 Py_DECREF(lo);
28948 Py_DECREF(shifter);
28949 Py_DECREF(shifted);
28950 }
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28958 PyObject *resultobj = 0;
28959 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28960 wxLongLong result;
28961 void *argp1 = 0 ;
28962 int res1 = 0 ;
28963 PyObject *swig_obj[1] ;
28964
28965 if (!args) SWIG_fail;
28966 swig_obj[0] = args;
28967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28968 if (!SWIG_IsOK(res1)) {
28969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28970 }
28971 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28975 wxPyEndAllowThreads(__tstate);
28976 if (PyErr_Occurred()) SWIG_fail;
28977 }
28978 {
28979 PyObject *hi, *lo, *shifter, *shifted;
28980 hi = PyLong_FromLong( (&result)->GetHi() );
28981 lo = PyLong_FromLong( (&result)->GetLo() );
28982 shifter = PyLong_FromLong(32);
28983 shifted = PyNumber_Lshift(hi, shifter);
28984 resultobj = PyNumber_Or(shifted, lo);
28985 Py_DECREF(hi);
28986 Py_DECREF(lo);
28987 Py_DECREF(shifter);
28988 Py_DECREF(shifted);
28989 }
28990 return resultobj;
28991 fail:
28992 return NULL;
28993 }
28994
28995
28996 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28997 PyObject *resultobj = 0;
28998 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28999 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29000 wxString *arg2 = (wxString *) &arg2_defvalue ;
29001 wxString result;
29002 void *argp1 = 0 ;
29003 int res1 = 0 ;
29004 bool temp2 = false ;
29005 PyObject * obj0 = 0 ;
29006 PyObject * obj1 = 0 ;
29007 char * kwnames[] = {
29008 (char *) "self",(char *) "format", NULL
29009 };
29010
29011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29013 if (!SWIG_IsOK(res1)) {
29014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29015 }
29016 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29017 if (obj1) {
29018 {
29019 arg2 = wxString_in_helper(obj1);
29020 if (arg2 == NULL) SWIG_fail;
29021 temp2 = true;
29022 }
29023 }
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 {
29031 #if wxUSE_UNICODE
29032 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29033 #else
29034 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29035 #endif
29036 }
29037 {
29038 if (temp2)
29039 delete arg2;
29040 }
29041 return resultobj;
29042 fail:
29043 {
29044 if (temp2)
29045 delete arg2;
29046 }
29047 return NULL;
29048 }
29049
29050
29051 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29052 PyObject *obj;
29053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29054 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
29055 return SWIG_Py_Void();
29056 }
29057
29058 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29059 return SWIG_Python_InitShadowInstance(args);
29060 }
29061
29062 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj = 0;
29064 int arg1 = (int) 0 ;
29065 int arg2 = (int) 0 ;
29066 int arg3 = (int) 0 ;
29067 int arg4 = (int) 0 ;
29068 wxDateSpan *result = 0 ;
29069 int val1 ;
29070 int ecode1 = 0 ;
29071 int val2 ;
29072 int ecode2 = 0 ;
29073 int val3 ;
29074 int ecode3 = 0 ;
29075 int val4 ;
29076 int ecode4 = 0 ;
29077 PyObject * obj0 = 0 ;
29078 PyObject * obj1 = 0 ;
29079 PyObject * obj2 = 0 ;
29080 PyObject * obj3 = 0 ;
29081 char * kwnames[] = {
29082 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
29083 };
29084
29085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29086 if (obj0) {
29087 ecode1 = SWIG_AsVal_int(obj0, &val1);
29088 if (!SWIG_IsOK(ecode1)) {
29089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
29090 }
29091 arg1 = static_cast< int >(val1);
29092 }
29093 if (obj1) {
29094 ecode2 = SWIG_AsVal_int(obj1, &val2);
29095 if (!SWIG_IsOK(ecode2)) {
29096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
29097 }
29098 arg2 = static_cast< int >(val2);
29099 }
29100 if (obj2) {
29101 ecode3 = SWIG_AsVal_int(obj2, &val3);
29102 if (!SWIG_IsOK(ecode3)) {
29103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
29104 }
29105 arg3 = static_cast< int >(val3);
29106 }
29107 if (obj3) {
29108 ecode4 = SWIG_AsVal_int(obj3, &val4);
29109 if (!SWIG_IsOK(ecode4)) {
29110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
29111 }
29112 arg4 = static_cast< int >(val4);
29113 }
29114 {
29115 PyThreadState* __tstate = wxPyBeginAllowThreads();
29116 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29117 wxPyEndAllowThreads(__tstate);
29118 if (PyErr_Occurred()) SWIG_fail;
29119 }
29120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29128 PyObject *resultobj = 0;
29129 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29130 void *argp1 = 0 ;
29131 int res1 = 0 ;
29132 PyObject *swig_obj[1] ;
29133
29134 if (!args) SWIG_fail;
29135 swig_obj[0] = args;
29136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29137 if (!SWIG_IsOK(res1)) {
29138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29139 }
29140 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 delete arg1;
29144
29145 wxPyEndAllowThreads(__tstate);
29146 if (PyErr_Occurred()) SWIG_fail;
29147 }
29148 resultobj = SWIG_Py_Void();
29149 return resultobj;
29150 fail:
29151 return NULL;
29152 }
29153
29154
29155 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29156 PyObject *resultobj = 0;
29157 int arg1 ;
29158 wxDateSpan result;
29159 int val1 ;
29160 int ecode1 = 0 ;
29161 PyObject * obj0 = 0 ;
29162 char * kwnames[] = {
29163 (char *) "days", NULL
29164 };
29165
29166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29167 ecode1 = SWIG_AsVal_int(obj0, &val1);
29168 if (!SWIG_IsOK(ecode1)) {
29169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29170 }
29171 arg1 = static_cast< int >(val1);
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = wxDateSpan::Days(arg1);
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29186 PyObject *resultobj = 0;
29187 wxDateSpan result;
29188
29189 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29190 {
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 result = wxDateSpan::Day();
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29204 PyObject *resultobj = 0;
29205 int arg1 ;
29206 wxDateSpan result;
29207 int val1 ;
29208 int ecode1 = 0 ;
29209 PyObject * obj0 = 0 ;
29210 char * kwnames[] = {
29211 (char *) "weeks", NULL
29212 };
29213
29214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29215 ecode1 = SWIG_AsVal_int(obj0, &val1);
29216 if (!SWIG_IsOK(ecode1)) {
29217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29218 }
29219 arg1 = static_cast< int >(val1);
29220 {
29221 PyThreadState* __tstate = wxPyBeginAllowThreads();
29222 result = wxDateSpan::Weeks(arg1);
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29234 PyObject *resultobj = 0;
29235 wxDateSpan result;
29236
29237 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29238 {
29239 PyThreadState* __tstate = wxPyBeginAllowThreads();
29240 result = wxDateSpan::Week();
29241 wxPyEndAllowThreads(__tstate);
29242 if (PyErr_Occurred()) SWIG_fail;
29243 }
29244 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29252 PyObject *resultobj = 0;
29253 int arg1 ;
29254 wxDateSpan result;
29255 int val1 ;
29256 int ecode1 = 0 ;
29257 PyObject * obj0 = 0 ;
29258 char * kwnames[] = {
29259 (char *) "mon", NULL
29260 };
29261
29262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29263 ecode1 = SWIG_AsVal_int(obj0, &val1);
29264 if (!SWIG_IsOK(ecode1)) {
29265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29266 }
29267 arg1 = static_cast< int >(val1);
29268 {
29269 PyThreadState* __tstate = wxPyBeginAllowThreads();
29270 result = wxDateSpan::Months(arg1);
29271 wxPyEndAllowThreads(__tstate);
29272 if (PyErr_Occurred()) SWIG_fail;
29273 }
29274 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29275 return resultobj;
29276 fail:
29277 return NULL;
29278 }
29279
29280
29281 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29282 PyObject *resultobj = 0;
29283 wxDateSpan result;
29284
29285 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29286 {
29287 PyThreadState* __tstate = wxPyBeginAllowThreads();
29288 result = wxDateSpan::Month();
29289 wxPyEndAllowThreads(__tstate);
29290 if (PyErr_Occurred()) SWIG_fail;
29291 }
29292 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29293 return resultobj;
29294 fail:
29295 return NULL;
29296 }
29297
29298
29299 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29300 PyObject *resultobj = 0;
29301 int arg1 ;
29302 wxDateSpan result;
29303 int val1 ;
29304 int ecode1 = 0 ;
29305 PyObject * obj0 = 0 ;
29306 char * kwnames[] = {
29307 (char *) "years", NULL
29308 };
29309
29310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29311 ecode1 = SWIG_AsVal_int(obj0, &val1);
29312 if (!SWIG_IsOK(ecode1)) {
29313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29314 }
29315 arg1 = static_cast< int >(val1);
29316 {
29317 PyThreadState* __tstate = wxPyBeginAllowThreads();
29318 result = wxDateSpan::Years(arg1);
29319 wxPyEndAllowThreads(__tstate);
29320 if (PyErr_Occurred()) SWIG_fail;
29321 }
29322 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29323 return resultobj;
29324 fail:
29325 return NULL;
29326 }
29327
29328
29329 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29330 PyObject *resultobj = 0;
29331 wxDateSpan result;
29332
29333 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29334 {
29335 PyThreadState* __tstate = wxPyBeginAllowThreads();
29336 result = wxDateSpan::Year();
29337 wxPyEndAllowThreads(__tstate);
29338 if (PyErr_Occurred()) SWIG_fail;
29339 }
29340 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29348 PyObject *resultobj = 0;
29349 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29350 int arg2 ;
29351 wxDateSpan *result = 0 ;
29352 void *argp1 = 0 ;
29353 int res1 = 0 ;
29354 int val2 ;
29355 int ecode2 = 0 ;
29356 PyObject * obj0 = 0 ;
29357 PyObject * obj1 = 0 ;
29358 char * kwnames[] = {
29359 (char *) "self",(char *) "n", NULL
29360 };
29361
29362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29364 if (!SWIG_IsOK(res1)) {
29365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29366 }
29367 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29368 ecode2 = SWIG_AsVal_int(obj1, &val2);
29369 if (!SWIG_IsOK(ecode2)) {
29370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29371 }
29372 arg2 = static_cast< int >(val2);
29373 {
29374 PyThreadState* __tstate = wxPyBeginAllowThreads();
29375 {
29376 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29377 result = (wxDateSpan *) &_result_ref;
29378 }
29379 wxPyEndAllowThreads(__tstate);
29380 if (PyErr_Occurred()) SWIG_fail;
29381 }
29382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29383 return resultobj;
29384 fail:
29385 return NULL;
29386 }
29387
29388
29389 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29390 PyObject *resultobj = 0;
29391 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29392 int arg2 ;
29393 wxDateSpan *result = 0 ;
29394 void *argp1 = 0 ;
29395 int res1 = 0 ;
29396 int val2 ;
29397 int ecode2 = 0 ;
29398 PyObject * obj0 = 0 ;
29399 PyObject * obj1 = 0 ;
29400 char * kwnames[] = {
29401 (char *) "self",(char *) "n", NULL
29402 };
29403
29404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29406 if (!SWIG_IsOK(res1)) {
29407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29408 }
29409 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29410 ecode2 = SWIG_AsVal_int(obj1, &val2);
29411 if (!SWIG_IsOK(ecode2)) {
29412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29413 }
29414 arg2 = static_cast< int >(val2);
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 {
29418 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29419 result = (wxDateSpan *) &_result_ref;
29420 }
29421 wxPyEndAllowThreads(__tstate);
29422 if (PyErr_Occurred()) SWIG_fail;
29423 }
29424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29425 return resultobj;
29426 fail:
29427 return NULL;
29428 }
29429
29430
29431 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29432 PyObject *resultobj = 0;
29433 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29434 int arg2 ;
29435 wxDateSpan *result = 0 ;
29436 void *argp1 = 0 ;
29437 int res1 = 0 ;
29438 int val2 ;
29439 int ecode2 = 0 ;
29440 PyObject * obj0 = 0 ;
29441 PyObject * obj1 = 0 ;
29442 char * kwnames[] = {
29443 (char *) "self",(char *) "n", NULL
29444 };
29445
29446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29448 if (!SWIG_IsOK(res1)) {
29449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29450 }
29451 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29452 ecode2 = SWIG_AsVal_int(obj1, &val2);
29453 if (!SWIG_IsOK(ecode2)) {
29454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29455 }
29456 arg2 = static_cast< int >(val2);
29457 {
29458 PyThreadState* __tstate = wxPyBeginAllowThreads();
29459 {
29460 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29461 result = (wxDateSpan *) &_result_ref;
29462 }
29463 wxPyEndAllowThreads(__tstate);
29464 if (PyErr_Occurred()) SWIG_fail;
29465 }
29466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29474 PyObject *resultobj = 0;
29475 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29476 int arg2 ;
29477 wxDateSpan *result = 0 ;
29478 void *argp1 = 0 ;
29479 int res1 = 0 ;
29480 int val2 ;
29481 int ecode2 = 0 ;
29482 PyObject * obj0 = 0 ;
29483 PyObject * obj1 = 0 ;
29484 char * kwnames[] = {
29485 (char *) "self",(char *) "n", NULL
29486 };
29487
29488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29490 if (!SWIG_IsOK(res1)) {
29491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29492 }
29493 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29494 ecode2 = SWIG_AsVal_int(obj1, &val2);
29495 if (!SWIG_IsOK(ecode2)) {
29496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29497 }
29498 arg2 = static_cast< int >(val2);
29499 {
29500 PyThreadState* __tstate = wxPyBeginAllowThreads();
29501 {
29502 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29503 result = (wxDateSpan *) &_result_ref;
29504 }
29505 wxPyEndAllowThreads(__tstate);
29506 if (PyErr_Occurred()) SWIG_fail;
29507 }
29508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29509 return resultobj;
29510 fail:
29511 return NULL;
29512 }
29513
29514
29515 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29516 PyObject *resultobj = 0;
29517 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29518 int result;
29519 void *argp1 = 0 ;
29520 int res1 = 0 ;
29521 PyObject *swig_obj[1] ;
29522
29523 if (!args) SWIG_fail;
29524 swig_obj[0] = args;
29525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29526 if (!SWIG_IsOK(res1)) {
29527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29528 }
29529 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29530 {
29531 PyThreadState* __tstate = wxPyBeginAllowThreads();
29532 result = (int)((wxDateSpan const *)arg1)->GetYears();
29533 wxPyEndAllowThreads(__tstate);
29534 if (PyErr_Occurred()) SWIG_fail;
29535 }
29536 resultobj = SWIG_From_int(static_cast< int >(result));
29537 return resultobj;
29538 fail:
29539 return NULL;
29540 }
29541
29542
29543 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29544 PyObject *resultobj = 0;
29545 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29546 int result;
29547 void *argp1 = 0 ;
29548 int res1 = 0 ;
29549 PyObject *swig_obj[1] ;
29550
29551 if (!args) SWIG_fail;
29552 swig_obj[0] = args;
29553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29554 if (!SWIG_IsOK(res1)) {
29555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29556 }
29557 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29558 {
29559 PyThreadState* __tstate = wxPyBeginAllowThreads();
29560 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29561 wxPyEndAllowThreads(__tstate);
29562 if (PyErr_Occurred()) SWIG_fail;
29563 }
29564 resultobj = SWIG_From_int(static_cast< int >(result));
29565 return resultobj;
29566 fail:
29567 return NULL;
29568 }
29569
29570
29571 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29572 PyObject *resultobj = 0;
29573 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29574 int result;
29575 void *argp1 = 0 ;
29576 int res1 = 0 ;
29577 PyObject *swig_obj[1] ;
29578
29579 if (!args) SWIG_fail;
29580 swig_obj[0] = args;
29581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29582 if (!SWIG_IsOK(res1)) {
29583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29584 }
29585 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 resultobj = SWIG_From_int(static_cast< int >(result));
29593 return resultobj;
29594 fail:
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29600 PyObject *resultobj = 0;
29601 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29602 int result;
29603 void *argp1 = 0 ;
29604 int res1 = 0 ;
29605 PyObject *swig_obj[1] ;
29606
29607 if (!args) SWIG_fail;
29608 swig_obj[0] = args;
29609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29612 }
29613 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 result = (int)((wxDateSpan const *)arg1)->GetDays();
29617 wxPyEndAllowThreads(__tstate);
29618 if (PyErr_Occurred()) SWIG_fail;
29619 }
29620 resultobj = SWIG_From_int(static_cast< int >(result));
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29628 PyObject *resultobj = 0;
29629 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29630 int result;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 PyObject *swig_obj[1] ;
29634
29635 if (!args) SWIG_fail;
29636 swig_obj[0] = args;
29637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29638 if (!SWIG_IsOK(res1)) {
29639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29640 }
29641 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 resultobj = SWIG_From_int(static_cast< int >(result));
29649 return resultobj;
29650 fail:
29651 return NULL;
29652 }
29653
29654
29655 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29656 PyObject *resultobj = 0;
29657 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29658 wxDateSpan *arg2 = 0 ;
29659 wxDateSpan *result = 0 ;
29660 void *argp1 = 0 ;
29661 int res1 = 0 ;
29662 void *argp2 = 0 ;
29663 int res2 = 0 ;
29664 PyObject * obj0 = 0 ;
29665 PyObject * obj1 = 0 ;
29666 char * kwnames[] = {
29667 (char *) "self",(char *) "other", NULL
29668 };
29669
29670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29672 if (!SWIG_IsOK(res1)) {
29673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29674 }
29675 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29676 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29677 if (!SWIG_IsOK(res2)) {
29678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29679 }
29680 if (!argp2) {
29681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29682 }
29683 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 {
29687 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29688 result = (wxDateSpan *) &_result_ref;
29689 }
29690 wxPyEndAllowThreads(__tstate);
29691 if (PyErr_Occurred()) SWIG_fail;
29692 }
29693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29701 PyObject *resultobj = 0;
29702 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29703 wxDateSpan *arg2 = 0 ;
29704 wxDateSpan *result = 0 ;
29705 void *argp1 = 0 ;
29706 int res1 = 0 ;
29707 void *argp2 = 0 ;
29708 int res2 = 0 ;
29709 PyObject * obj0 = 0 ;
29710 PyObject * obj1 = 0 ;
29711 char * kwnames[] = {
29712 (char *) "self",(char *) "other", NULL
29713 };
29714
29715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29719 }
29720 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29722 if (!SWIG_IsOK(res2)) {
29723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29724 }
29725 if (!argp2) {
29726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29727 }
29728 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 {
29732 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29733 result = (wxDateSpan *) &_result_ref;
29734 }
29735 wxPyEndAllowThreads(__tstate);
29736 if (PyErr_Occurred()) SWIG_fail;
29737 }
29738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29746 PyObject *resultobj = 0;
29747 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29748 wxDateSpan *result = 0 ;
29749 void *argp1 = 0 ;
29750 int res1 = 0 ;
29751 PyObject *swig_obj[1] ;
29752
29753 if (!args) SWIG_fail;
29754 swig_obj[0] = args;
29755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29756 if (!SWIG_IsOK(res1)) {
29757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29758 }
29759 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 {
29763 wxDateSpan &_result_ref = (arg1)->Neg();
29764 result = (wxDateSpan *) &_result_ref;
29765 }
29766 wxPyEndAllowThreads(__tstate);
29767 if (PyErr_Occurred()) SWIG_fail;
29768 }
29769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29770 return resultobj;
29771 fail:
29772 return NULL;
29773 }
29774
29775
29776 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29777 PyObject *resultobj = 0;
29778 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29779 int arg2 ;
29780 wxDateSpan *result = 0 ;
29781 void *argp1 = 0 ;
29782 int res1 = 0 ;
29783 int val2 ;
29784 int ecode2 = 0 ;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 char * kwnames[] = {
29788 (char *) "self",(char *) "factor", NULL
29789 };
29790
29791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29793 if (!SWIG_IsOK(res1)) {
29794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29795 }
29796 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29797 ecode2 = SWIG_AsVal_int(obj1, &val2);
29798 if (!SWIG_IsOK(ecode2)) {
29799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29800 }
29801 arg2 = static_cast< int >(val2);
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 {
29805 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29806 result = (wxDateSpan *) &_result_ref;
29807 }
29808 wxPyEndAllowThreads(__tstate);
29809 if (PyErr_Occurred()) SWIG_fail;
29810 }
29811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29819 PyObject *resultobj = 0;
29820 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29821 wxDateSpan *arg2 = 0 ;
29822 wxDateSpan *result = 0 ;
29823 void *argp1 = 0 ;
29824 int res1 = 0 ;
29825 void *argp2 = 0 ;
29826 int res2 = 0 ;
29827 PyObject * obj0 = 0 ;
29828 PyObject * obj1 = 0 ;
29829 char * kwnames[] = {
29830 (char *) "self",(char *) "other", NULL
29831 };
29832
29833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29835 if (!SWIG_IsOK(res1)) {
29836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29837 }
29838 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29840 if (!SWIG_IsOK(res2)) {
29841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29842 }
29843 if (!argp2) {
29844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29845 }
29846 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29847 {
29848 PyThreadState* __tstate = wxPyBeginAllowThreads();
29849 {
29850 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29851 result = (wxDateSpan *) &_result_ref;
29852 }
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29864 PyObject *resultobj = 0;
29865 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29866 wxDateSpan *arg2 = 0 ;
29867 wxDateSpan *result = 0 ;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 void *argp2 = 0 ;
29871 int res2 = 0 ;
29872 PyObject * obj0 = 0 ;
29873 PyObject * obj1 = 0 ;
29874 char * kwnames[] = {
29875 (char *) "self",(char *) "other", NULL
29876 };
29877
29878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29880 if (!SWIG_IsOK(res1)) {
29881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29882 }
29883 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29884 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29885 if (!SWIG_IsOK(res2)) {
29886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29887 }
29888 if (!argp2) {
29889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29890 }
29891 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 {
29895 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29896 result = (wxDateSpan *) &_result_ref;
29897 }
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29909 PyObject *resultobj = 0;
29910 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29911 wxDateSpan *result = 0 ;
29912 void *argp1 = 0 ;
29913 int res1 = 0 ;
29914 PyObject *swig_obj[1] ;
29915
29916 if (!args) SWIG_fail;
29917 swig_obj[0] = args;
29918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29919 if (!SWIG_IsOK(res1)) {
29920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29921 }
29922 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 {
29926 wxDateSpan &_result_ref = (arg1)->operator -();
29927 result = (wxDateSpan *) &_result_ref;
29928 }
29929 wxPyEndAllowThreads(__tstate);
29930 if (PyErr_Occurred()) SWIG_fail;
29931 }
29932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29933 return resultobj;
29934 fail:
29935 return NULL;
29936 }
29937
29938
29939 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29940 PyObject *resultobj = 0;
29941 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29942 int arg2 ;
29943 wxDateSpan *result = 0 ;
29944 void *argp1 = 0 ;
29945 int res1 = 0 ;
29946 int val2 ;
29947 int ecode2 = 0 ;
29948 PyObject * obj0 = 0 ;
29949 PyObject * obj1 = 0 ;
29950 char * kwnames[] = {
29951 (char *) "self",(char *) "factor", NULL
29952 };
29953
29954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29956 if (!SWIG_IsOK(res1)) {
29957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29958 }
29959 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29960 ecode2 = SWIG_AsVal_int(obj1, &val2);
29961 if (!SWIG_IsOK(ecode2)) {
29962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29963 }
29964 arg2 = static_cast< int >(val2);
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 {
29968 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29969 result = (wxDateSpan *) &_result_ref;
29970 }
29971 wxPyEndAllowThreads(__tstate);
29972 if (PyErr_Occurred()) SWIG_fail;
29973 }
29974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29982 PyObject *resultobj = 0;
29983 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29984 wxDateSpan *arg2 = 0 ;
29985 wxDateSpan result;
29986 void *argp1 = 0 ;
29987 int res1 = 0 ;
29988 void *argp2 = 0 ;
29989 int res2 = 0 ;
29990 PyObject * obj0 = 0 ;
29991 PyObject * obj1 = 0 ;
29992 char * kwnames[] = {
29993 (char *) "self",(char *) "other", NULL
29994 };
29995
29996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29998 if (!SWIG_IsOK(res1)) {
29999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30000 }
30001 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30002 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30003 if (!SWIG_IsOK(res2)) {
30004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30005 }
30006 if (!argp2) {
30007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30008 }
30009 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30010 {
30011 PyThreadState* __tstate = wxPyBeginAllowThreads();
30012 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30013 wxPyEndAllowThreads(__tstate);
30014 if (PyErr_Occurred()) SWIG_fail;
30015 }
30016 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30017 return resultobj;
30018 fail:
30019 return NULL;
30020 }
30021
30022
30023 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30024 PyObject *resultobj = 0;
30025 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30026 wxDateSpan *arg2 = 0 ;
30027 wxDateSpan result;
30028 void *argp1 = 0 ;
30029 int res1 = 0 ;
30030 void *argp2 = 0 ;
30031 int res2 = 0 ;
30032 PyObject * obj0 = 0 ;
30033 PyObject * obj1 = 0 ;
30034 char * kwnames[] = {
30035 (char *) "self",(char *) "other", NULL
30036 };
30037
30038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30042 }
30043 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30044 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30045 if (!SWIG_IsOK(res2)) {
30046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30047 }
30048 if (!argp2) {
30049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30050 }
30051 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30052 {
30053 PyThreadState* __tstate = wxPyBeginAllowThreads();
30054 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
30055 wxPyEndAllowThreads(__tstate);
30056 if (PyErr_Occurred()) SWIG_fail;
30057 }
30058 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30059 return resultobj;
30060 fail:
30061 return NULL;
30062 }
30063
30064
30065 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30066 PyObject *resultobj = 0;
30067 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30068 int arg2 ;
30069 wxDateSpan result;
30070 void *argp1 = 0 ;
30071 int res1 = 0 ;
30072 int val2 ;
30073 int ecode2 = 0 ;
30074 PyObject * obj0 = 0 ;
30075 PyObject * obj1 = 0 ;
30076 char * kwnames[] = {
30077 (char *) "self",(char *) "n", NULL
30078 };
30079
30080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
30081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30082 if (!SWIG_IsOK(res1)) {
30083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30084 }
30085 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30086 ecode2 = SWIG_AsVal_int(obj1, &val2);
30087 if (!SWIG_IsOK(ecode2)) {
30088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
30089 }
30090 arg2 = static_cast< int >(val2);
30091 {
30092 PyThreadState* __tstate = wxPyBeginAllowThreads();
30093 result = wxDateSpan___mul__(arg1,arg2);
30094 wxPyEndAllowThreads(__tstate);
30095 if (PyErr_Occurred()) SWIG_fail;
30096 }
30097 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30098 return resultobj;
30099 fail:
30100 return NULL;
30101 }
30102
30103
30104 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30105 PyObject *resultobj = 0;
30106 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30107 int arg2 ;
30108 wxDateSpan result;
30109 void *argp1 = 0 ;
30110 int res1 = 0 ;
30111 int val2 ;
30112 int ecode2 = 0 ;
30113 PyObject * obj0 = 0 ;
30114 PyObject * obj1 = 0 ;
30115 char * kwnames[] = {
30116 (char *) "self",(char *) "n", NULL
30117 };
30118
30119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30121 if (!SWIG_IsOK(res1)) {
30122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30123 }
30124 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30125 ecode2 = SWIG_AsVal_int(obj1, &val2);
30126 if (!SWIG_IsOK(ecode2)) {
30127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30128 }
30129 arg2 = static_cast< int >(val2);
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = wxDateSpan___rmul__(arg1,arg2);
30133 wxPyEndAllowThreads(__tstate);
30134 if (PyErr_Occurred()) SWIG_fail;
30135 }
30136 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30137 return resultobj;
30138 fail:
30139 return NULL;
30140 }
30141
30142
30143 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30144 PyObject *resultobj = 0;
30145 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30146 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30147 bool result;
30148 void *argp1 = 0 ;
30149 int res1 = 0 ;
30150 void *argp2 = 0 ;
30151 int res2 = 0 ;
30152 PyObject * obj0 = 0 ;
30153 PyObject * obj1 = 0 ;
30154 char * kwnames[] = {
30155 (char *) "self",(char *) "other", NULL
30156 };
30157
30158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30160 if (!SWIG_IsOK(res1)) {
30161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30162 }
30163 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30165 if (!SWIG_IsOK(res2)) {
30166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30167 }
30168 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30169 {
30170 PyThreadState* __tstate = wxPyBeginAllowThreads();
30171 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30172 wxPyEndAllowThreads(__tstate);
30173 if (PyErr_Occurred()) SWIG_fail;
30174 }
30175 {
30176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30177 }
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30185 PyObject *resultobj = 0;
30186 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30187 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30188 bool result;
30189 void *argp1 = 0 ;
30190 int res1 = 0 ;
30191 void *argp2 = 0 ;
30192 int res2 = 0 ;
30193 PyObject * obj0 = 0 ;
30194 PyObject * obj1 = 0 ;
30195 char * kwnames[] = {
30196 (char *) "self",(char *) "other", NULL
30197 };
30198
30199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30201 if (!SWIG_IsOK(res1)) {
30202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30203 }
30204 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30206 if (!SWIG_IsOK(res2)) {
30207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30208 }
30209 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30210 {
30211 PyThreadState* __tstate = wxPyBeginAllowThreads();
30212 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30213 wxPyEndAllowThreads(__tstate);
30214 if (PyErr_Occurred()) SWIG_fail;
30215 }
30216 {
30217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30218 }
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30226 PyObject *obj;
30227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30228 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30229 return SWIG_Py_Void();
30230 }
30231
30232 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30233 return SWIG_Python_InitShadowInstance(args);
30234 }
30235
30236 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30237 PyObject *resultobj = 0;
30238 long result;
30239
30240 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = (long)wxGetLocalTime();
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 resultobj = SWIG_From_long(static_cast< long >(result));
30248 return resultobj;
30249 fail:
30250 return NULL;
30251 }
30252
30253
30254 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30255 PyObject *resultobj = 0;
30256 long result;
30257
30258 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 result = (long)wxGetUTCTime();
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 resultobj = SWIG_From_long(static_cast< long >(result));
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30273 PyObject *resultobj = 0;
30274 long result;
30275
30276 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30277 {
30278 PyThreadState* __tstate = wxPyBeginAllowThreads();
30279 result = (long)wxGetCurrentTime();
30280 wxPyEndAllowThreads(__tstate);
30281 if (PyErr_Occurred()) SWIG_fail;
30282 }
30283 resultobj = SWIG_From_long(static_cast< long >(result));
30284 return resultobj;
30285 fail:
30286 return NULL;
30287 }
30288
30289
30290 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30291 PyObject *resultobj = 0;
30292 wxLongLong result;
30293
30294 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30295 {
30296 PyThreadState* __tstate = wxPyBeginAllowThreads();
30297 result = wxGetLocalTimeMillis();
30298 wxPyEndAllowThreads(__tstate);
30299 if (PyErr_Occurred()) SWIG_fail;
30300 }
30301 {
30302 PyObject *hi, *lo, *shifter, *shifted;
30303 hi = PyLong_FromLong( (&result)->GetHi() );
30304 lo = PyLong_FromLong( (&result)->GetLo() );
30305 shifter = PyLong_FromLong(32);
30306 shifted = PyNumber_Lshift(hi, shifter);
30307 resultobj = PyNumber_Or(shifted, lo);
30308 Py_DECREF(hi);
30309 Py_DECREF(lo);
30310 Py_DECREF(shifter);
30311 Py_DECREF(shifted);
30312 }
30313 return resultobj;
30314 fail:
30315 return NULL;
30316 }
30317
30318
30319 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30320 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30321 return 1;
30322 }
30323
30324
30325 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30326 PyObject *pyobj = 0;
30327
30328 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30329 return pyobj;
30330 }
30331
30332
30333 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj = 0;
30335 wxDataFormatId arg1 ;
30336 wxDataFormat *result = 0 ;
30337 int val1 ;
30338 int ecode1 = 0 ;
30339 PyObject * obj0 = 0 ;
30340 char * kwnames[] = {
30341 (char *) "type", NULL
30342 };
30343
30344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30345 ecode1 = SWIG_AsVal_int(obj0, &val1);
30346 if (!SWIG_IsOK(ecode1)) {
30347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30348 }
30349 arg1 = static_cast< wxDataFormatId >(val1);
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 result = (wxDataFormat *)new wxDataFormat(arg1);
30353 wxPyEndAllowThreads(__tstate);
30354 if (PyErr_Occurred()) SWIG_fail;
30355 }
30356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30357 return resultobj;
30358 fail:
30359 return NULL;
30360 }
30361
30362
30363 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30364 PyObject *resultobj = 0;
30365 wxString *arg1 = 0 ;
30366 wxDataFormat *result = 0 ;
30367 bool temp1 = false ;
30368 PyObject * obj0 = 0 ;
30369 char * kwnames[] = {
30370 (char *) "format", NULL
30371 };
30372
30373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30374 {
30375 arg1 = wxString_in_helper(obj0);
30376 if (arg1 == NULL) SWIG_fail;
30377 temp1 = true;
30378 }
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30382 wxPyEndAllowThreads(__tstate);
30383 if (PyErr_Occurred()) SWIG_fail;
30384 }
30385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30386 {
30387 if (temp1)
30388 delete arg1;
30389 }
30390 return resultobj;
30391 fail:
30392 {
30393 if (temp1)
30394 delete arg1;
30395 }
30396 return NULL;
30397 }
30398
30399
30400 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30401 PyObject *resultobj = 0;
30402 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30403 void *argp1 = 0 ;
30404 int res1 = 0 ;
30405 PyObject *swig_obj[1] ;
30406
30407 if (!args) SWIG_fail;
30408 swig_obj[0] = args;
30409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30410 if (!SWIG_IsOK(res1)) {
30411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30412 }
30413 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 delete arg1;
30417
30418 wxPyEndAllowThreads(__tstate);
30419 if (PyErr_Occurred()) SWIG_fail;
30420 }
30421 resultobj = SWIG_Py_Void();
30422 return resultobj;
30423 fail:
30424 return NULL;
30425 }
30426
30427
30428 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30429 PyObject *resultobj = 0;
30430 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30431 wxDataFormatId arg2 ;
30432 bool result;
30433 void *argp1 = 0 ;
30434 int res1 = 0 ;
30435 int val2 ;
30436 int ecode2 = 0 ;
30437
30438 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30440 if (!SWIG_IsOK(res1)) {
30441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30442 }
30443 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30444 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30445 if (!SWIG_IsOK(ecode2)) {
30446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30447 }
30448 arg2 = static_cast< wxDataFormatId >(val2);
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30452 wxPyEndAllowThreads(__tstate);
30453 if (PyErr_Occurred()) SWIG_fail;
30454 }
30455 {
30456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30457 }
30458 return resultobj;
30459 fail:
30460 return NULL;
30461 }
30462
30463
30464 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30465 PyObject *resultobj = 0;
30466 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30467 wxDataFormatId arg2 ;
30468 bool result;
30469 void *argp1 = 0 ;
30470 int res1 = 0 ;
30471 int val2 ;
30472 int ecode2 = 0 ;
30473
30474 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30476 if (!SWIG_IsOK(res1)) {
30477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30478 }
30479 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30480 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30481 if (!SWIG_IsOK(ecode2)) {
30482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30483 }
30484 arg2 = static_cast< wxDataFormatId >(val2);
30485 {
30486 PyThreadState* __tstate = wxPyBeginAllowThreads();
30487 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30488 wxPyEndAllowThreads(__tstate);
30489 if (PyErr_Occurred()) SWIG_fail;
30490 }
30491 {
30492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30493 }
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30501 PyObject *resultobj = 0;
30502 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30503 wxDataFormat *arg2 = 0 ;
30504 bool result;
30505 void *argp1 = 0 ;
30506 int res1 = 0 ;
30507 void *argp2 = 0 ;
30508 int res2 = 0 ;
30509
30510 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30512 if (!SWIG_IsOK(res1)) {
30513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30514 }
30515 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30516 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30517 if (!SWIG_IsOK(res2)) {
30518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30519 }
30520 if (!argp2) {
30521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30522 }
30523 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 {
30531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30532 }
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30540 int argc;
30541 PyObject *argv[3];
30542
30543 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30544 --argc;
30545 if (argc == 2) {
30546 int _v = 0;
30547 {
30548 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30549 _v = SWIG_CheckState(res);
30550 }
30551 if (!_v) goto check_1;
30552 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30553 }
30554 check_1:
30555
30556 if (argc == 2) {
30557 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30558 }
30559
30560 fail:
30561 Py_INCREF(Py_NotImplemented);
30562 return Py_NotImplemented;
30563 }
30564
30565
30566 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30567 PyObject *resultobj = 0;
30568 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30569 wxDataFormat *arg2 = 0 ;
30570 bool result;
30571 void *argp1 = 0 ;
30572 int res1 = 0 ;
30573 void *argp2 = 0 ;
30574 int res2 = 0 ;
30575
30576 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30578 if (!SWIG_IsOK(res1)) {
30579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30580 }
30581 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30582 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30583 if (!SWIG_IsOK(res2)) {
30584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30585 }
30586 if (!argp2) {
30587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30588 }
30589 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30593 wxPyEndAllowThreads(__tstate);
30594 if (PyErr_Occurred()) SWIG_fail;
30595 }
30596 {
30597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30598 }
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30606 int argc;
30607 PyObject *argv[3];
30608
30609 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30610 --argc;
30611 if (argc == 2) {
30612 int _v = 0;
30613 {
30614 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30615 _v = SWIG_CheckState(res);
30616 }
30617 if (!_v) goto check_1;
30618 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30619 }
30620 check_1:
30621
30622 if (argc == 2) {
30623 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30624 }
30625
30626 fail:
30627 Py_INCREF(Py_NotImplemented);
30628 return Py_NotImplemented;
30629 }
30630
30631
30632 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30633 PyObject *resultobj = 0;
30634 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30635 wxDataFormatId arg2 ;
30636 void *argp1 = 0 ;
30637 int res1 = 0 ;
30638 int val2 ;
30639 int ecode2 = 0 ;
30640 PyObject * obj0 = 0 ;
30641 PyObject * obj1 = 0 ;
30642 char * kwnames[] = {
30643 (char *) "self",(char *) "format", NULL
30644 };
30645
30646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30648 if (!SWIG_IsOK(res1)) {
30649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30650 }
30651 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30652 ecode2 = SWIG_AsVal_int(obj1, &val2);
30653 if (!SWIG_IsOK(ecode2)) {
30654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30655 }
30656 arg2 = static_cast< wxDataFormatId >(val2);
30657 {
30658 PyThreadState* __tstate = wxPyBeginAllowThreads();
30659 (arg1)->SetType(arg2);
30660 wxPyEndAllowThreads(__tstate);
30661 if (PyErr_Occurred()) SWIG_fail;
30662 }
30663 resultobj = SWIG_Py_Void();
30664 return resultobj;
30665 fail:
30666 return NULL;
30667 }
30668
30669
30670 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30671 PyObject *resultobj = 0;
30672 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30673 wxDataFormatId result;
30674 void *argp1 = 0 ;
30675 int res1 = 0 ;
30676 PyObject *swig_obj[1] ;
30677
30678 if (!args) SWIG_fail;
30679 swig_obj[0] = args;
30680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30681 if (!SWIG_IsOK(res1)) {
30682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30683 }
30684 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30685 {
30686 PyThreadState* __tstate = wxPyBeginAllowThreads();
30687 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30688 wxPyEndAllowThreads(__tstate);
30689 if (PyErr_Occurred()) SWIG_fail;
30690 }
30691 resultobj = SWIG_From_int(static_cast< int >(result));
30692 return resultobj;
30693 fail:
30694 return NULL;
30695 }
30696
30697
30698 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30699 PyObject *resultobj = 0;
30700 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30701 wxString result;
30702 void *argp1 = 0 ;
30703 int res1 = 0 ;
30704 PyObject *swig_obj[1] ;
30705
30706 if (!args) SWIG_fail;
30707 swig_obj[0] = args;
30708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30709 if (!SWIG_IsOK(res1)) {
30710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30711 }
30712 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 result = ((wxDataFormat const *)arg1)->GetId();
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 {
30720 #if wxUSE_UNICODE
30721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30722 #else
30723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30724 #endif
30725 }
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30733 PyObject *resultobj = 0;
30734 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30735 wxString *arg2 = 0 ;
30736 void *argp1 = 0 ;
30737 int res1 = 0 ;
30738 bool temp2 = false ;
30739 PyObject * obj0 = 0 ;
30740 PyObject * obj1 = 0 ;
30741 char * kwnames[] = {
30742 (char *) "self",(char *) "format", NULL
30743 };
30744
30745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30747 if (!SWIG_IsOK(res1)) {
30748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30749 }
30750 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30751 {
30752 arg2 = wxString_in_helper(obj1);
30753 if (arg2 == NULL) SWIG_fail;
30754 temp2 = true;
30755 }
30756 {
30757 PyThreadState* __tstate = wxPyBeginAllowThreads();
30758 (arg1)->SetId((wxString const &)*arg2);
30759 wxPyEndAllowThreads(__tstate);
30760 if (PyErr_Occurred()) SWIG_fail;
30761 }
30762 resultobj = SWIG_Py_Void();
30763 {
30764 if (temp2)
30765 delete arg2;
30766 }
30767 return resultobj;
30768 fail:
30769 {
30770 if (temp2)
30771 delete arg2;
30772 }
30773 return NULL;
30774 }
30775
30776
30777 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30778 PyObject *obj;
30779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30780 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30781 return SWIG_Py_Void();
30782 }
30783
30784 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30785 return SWIG_Python_InitShadowInstance(args);
30786 }
30787
30788 SWIGINTERN int FormatInvalid_set(PyObject *) {
30789 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30790 return 1;
30791 }
30792
30793
30794 SWIGINTERN PyObject *FormatInvalid_get(void) {
30795 PyObject *pyobj = 0;
30796
30797 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30798 return pyobj;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30803 PyObject *resultobj = 0;
30804 wxDataObject *arg1 = (wxDataObject *) 0 ;
30805 void *argp1 = 0 ;
30806 int res1 = 0 ;
30807 PyObject *swig_obj[1] ;
30808
30809 if (!args) SWIG_fail;
30810 swig_obj[0] = args;
30811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30812 if (!SWIG_IsOK(res1)) {
30813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30814 }
30815 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30816 {
30817 PyThreadState* __tstate = wxPyBeginAllowThreads();
30818 delete arg1;
30819
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 resultobj = SWIG_Py_Void();
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj = 0;
30832 wxDataObject *arg1 = (wxDataObject *) 0 ;
30833 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30834 SwigValueWrapper<wxDataFormat > result;
30835 void *argp1 = 0 ;
30836 int res1 = 0 ;
30837 int val2 ;
30838 int ecode2 = 0 ;
30839 PyObject * obj0 = 0 ;
30840 PyObject * obj1 = 0 ;
30841 char * kwnames[] = {
30842 (char *) "self",(char *) "dir", NULL
30843 };
30844
30845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30847 if (!SWIG_IsOK(res1)) {
30848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30849 }
30850 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30851 if (obj1) {
30852 ecode2 = SWIG_AsVal_int(obj1, &val2);
30853 if (!SWIG_IsOK(ecode2)) {
30854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30855 }
30856 arg2 = static_cast< wxDataObject::Direction >(val2);
30857 }
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30861 wxPyEndAllowThreads(__tstate);
30862 if (PyErr_Occurred()) SWIG_fail;
30863 }
30864 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30865 return resultobj;
30866 fail:
30867 return NULL;
30868 }
30869
30870
30871 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30872 PyObject *resultobj = 0;
30873 wxDataObject *arg1 = (wxDataObject *) 0 ;
30874 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30875 size_t result;
30876 void *argp1 = 0 ;
30877 int res1 = 0 ;
30878 int val2 ;
30879 int ecode2 = 0 ;
30880 PyObject * obj0 = 0 ;
30881 PyObject * obj1 = 0 ;
30882 char * kwnames[] = {
30883 (char *) "self",(char *) "dir", NULL
30884 };
30885
30886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30888 if (!SWIG_IsOK(res1)) {
30889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30890 }
30891 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30892 if (obj1) {
30893 ecode2 = SWIG_AsVal_int(obj1, &val2);
30894 if (!SWIG_IsOK(ecode2)) {
30895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30896 }
30897 arg2 = static_cast< wxDataObject::Direction >(val2);
30898 }
30899 {
30900 PyThreadState* __tstate = wxPyBeginAllowThreads();
30901 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30913 PyObject *resultobj = 0;
30914 wxDataObject *arg1 = (wxDataObject *) 0 ;
30915 wxDataFormat *arg2 = 0 ;
30916 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30917 bool result;
30918 void *argp1 = 0 ;
30919 int res1 = 0 ;
30920 void *argp2 = 0 ;
30921 int res2 = 0 ;
30922 int val3 ;
30923 int ecode3 = 0 ;
30924 PyObject * obj0 = 0 ;
30925 PyObject * obj1 = 0 ;
30926 PyObject * obj2 = 0 ;
30927 char * kwnames[] = {
30928 (char *) "self",(char *) "format",(char *) "dir", NULL
30929 };
30930
30931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30933 if (!SWIG_IsOK(res1)) {
30934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30935 }
30936 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30937 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30938 if (!SWIG_IsOK(res2)) {
30939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30940 }
30941 if (!argp2) {
30942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30943 }
30944 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30945 if (obj2) {
30946 ecode3 = SWIG_AsVal_int(obj2, &val3);
30947 if (!SWIG_IsOK(ecode3)) {
30948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30949 }
30950 arg3 = static_cast< wxDataObject::Direction >(val3);
30951 }
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 {
30959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30960 }
30961 return resultobj;
30962 fail:
30963 return NULL;
30964 }
30965
30966
30967 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30968 PyObject *resultobj = 0;
30969 wxDataObject *arg1 = (wxDataObject *) 0 ;
30970 wxDataFormat *arg2 = 0 ;
30971 size_t result;
30972 void *argp1 = 0 ;
30973 int res1 = 0 ;
30974 void *argp2 = 0 ;
30975 int res2 = 0 ;
30976 PyObject * obj0 = 0 ;
30977 PyObject * obj1 = 0 ;
30978 char * kwnames[] = {
30979 (char *) "self",(char *) "format", NULL
30980 };
30981
30982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30984 if (!SWIG_IsOK(res1)) {
30985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30986 }
30987 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30988 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30989 if (!SWIG_IsOK(res2)) {
30990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30991 }
30992 if (!argp2) {
30993 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30994 }
30995 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30999 wxPyEndAllowThreads(__tstate);
31000 if (PyErr_Occurred()) SWIG_fail;
31001 }
31002 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31003 return resultobj;
31004 fail:
31005 return NULL;
31006 }
31007
31008
31009 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31010 PyObject *resultobj = 0;
31011 wxDataObject *arg1 = (wxDataObject *) 0 ;
31012 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31013 PyObject *result = 0 ;
31014 void *argp1 = 0 ;
31015 int res1 = 0 ;
31016 int val2 ;
31017 int ecode2 = 0 ;
31018 PyObject * obj0 = 0 ;
31019 PyObject * obj1 = 0 ;
31020 char * kwnames[] = {
31021 (char *) "self",(char *) "dir", NULL
31022 };
31023
31024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31026 if (!SWIG_IsOK(res1)) {
31027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31028 }
31029 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31030 if (obj1) {
31031 ecode2 = SWIG_AsVal_int(obj1, &val2);
31032 if (!SWIG_IsOK(ecode2)) {
31033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31034 }
31035 arg2 = static_cast< wxDataObject::Direction >(val2);
31036 }
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31040 wxPyEndAllowThreads(__tstate);
31041 if (PyErr_Occurred()) SWIG_fail;
31042 }
31043 resultobj = result;
31044 return resultobj;
31045 fail:
31046 return NULL;
31047 }
31048
31049
31050 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31051 PyObject *resultobj = 0;
31052 wxDataObject *arg1 = (wxDataObject *) 0 ;
31053 wxDataFormat *arg2 = 0 ;
31054 PyObject *result = 0 ;
31055 void *argp1 = 0 ;
31056 int res1 = 0 ;
31057 void *argp2 = 0 ;
31058 int res2 = 0 ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 char * kwnames[] = {
31062 (char *) "self",(char *) "format", NULL
31063 };
31064
31065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
31066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31067 if (!SWIG_IsOK(res1)) {
31068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
31069 }
31070 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31071 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31072 if (!SWIG_IsOK(res2)) {
31073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31074 }
31075 if (!argp2) {
31076 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31077 }
31078 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 resultobj = result;
31086 return resultobj;
31087 fail:
31088 return NULL;
31089 }
31090
31091
31092 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31093 PyObject *resultobj = 0;
31094 wxDataObject *arg1 = (wxDataObject *) 0 ;
31095 wxDataFormat *arg2 = 0 ;
31096 PyObject *arg3 = (PyObject *) 0 ;
31097 bool result;
31098 void *argp1 = 0 ;
31099 int res1 = 0 ;
31100 void *argp2 = 0 ;
31101 int res2 = 0 ;
31102 PyObject * obj0 = 0 ;
31103 PyObject * obj1 = 0 ;
31104 PyObject * obj2 = 0 ;
31105 char * kwnames[] = {
31106 (char *) "self",(char *) "format",(char *) "data", NULL
31107 };
31108
31109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31111 if (!SWIG_IsOK(res1)) {
31112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
31113 }
31114 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31116 if (!SWIG_IsOK(res2)) {
31117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31118 }
31119 if (!argp2) {
31120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31121 }
31122 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31123 arg3 = obj2;
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31127 wxPyEndAllowThreads(__tstate);
31128 if (PyErr_Occurred()) SWIG_fail;
31129 }
31130 {
31131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31132 }
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31140 PyObject *obj;
31141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31142 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31143 return SWIG_Py_Void();
31144 }
31145
31146 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31147 PyObject *resultobj = 0;
31148 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31149 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31150 wxDataObjectSimple *result = 0 ;
31151 void *argp1 = 0 ;
31152 int res1 = 0 ;
31153 PyObject * obj0 = 0 ;
31154 char * kwnames[] = {
31155 (char *) "format", NULL
31156 };
31157
31158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31159 if (obj0) {
31160 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31161 if (!SWIG_IsOK(res1)) {
31162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31163 }
31164 if (!argp1) {
31165 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31166 }
31167 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31168 }
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31183 PyObject *resultobj = 0;
31184 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31185 wxDataFormat *result = 0 ;
31186 void *argp1 = 0 ;
31187 int res1 = 0 ;
31188 PyObject *swig_obj[1] ;
31189
31190 if (!args) SWIG_fail;
31191 swig_obj[0] = args;
31192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31193 if (!SWIG_IsOK(res1)) {
31194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31195 }
31196 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31197 {
31198 PyThreadState* __tstate = wxPyBeginAllowThreads();
31199 {
31200 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31201 result = (wxDataFormat *) &_result_ref;
31202 }
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj = 0;
31215 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31216 wxDataFormat *arg2 = 0 ;
31217 void *argp1 = 0 ;
31218 int res1 = 0 ;
31219 void *argp2 = 0 ;
31220 int res2 = 0 ;
31221 PyObject * obj0 = 0 ;
31222 PyObject * obj1 = 0 ;
31223 char * kwnames[] = {
31224 (char *) "self",(char *) "format", NULL
31225 };
31226
31227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31229 if (!SWIG_IsOK(res1)) {
31230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31231 }
31232 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31233 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31234 if (!SWIG_IsOK(res2)) {
31235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31236 }
31237 if (!argp2) {
31238 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31239 }
31240 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31241 {
31242 PyThreadState* __tstate = wxPyBeginAllowThreads();
31243 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31244 wxPyEndAllowThreads(__tstate);
31245 if (PyErr_Occurred()) SWIG_fail;
31246 }
31247 resultobj = SWIG_Py_Void();
31248 return resultobj;
31249 fail:
31250 return NULL;
31251 }
31252
31253
31254 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31255 PyObject *resultobj = 0;
31256 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31257 size_t result;
31258 void *argp1 = 0 ;
31259 int res1 = 0 ;
31260 PyObject *swig_obj[1] ;
31261
31262 if (!args) SWIG_fail;
31263 swig_obj[0] = args;
31264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31265 if (!SWIG_IsOK(res1)) {
31266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31267 }
31268 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31269 {
31270 PyThreadState* __tstate = wxPyBeginAllowThreads();
31271 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31283 PyObject *resultobj = 0;
31284 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31285 PyObject *result = 0 ;
31286 void *argp1 = 0 ;
31287 int res1 = 0 ;
31288 PyObject *swig_obj[1] ;
31289
31290 if (!args) SWIG_fail;
31291 swig_obj[0] = args;
31292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31293 if (!SWIG_IsOK(res1)) {
31294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31295 }
31296 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = result;
31304 return resultobj;
31305 fail:
31306 return NULL;
31307 }
31308
31309
31310 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31311 PyObject *resultobj = 0;
31312 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31313 PyObject *arg2 = (PyObject *) 0 ;
31314 bool result;
31315 void *argp1 = 0 ;
31316 int res1 = 0 ;
31317 PyObject * obj0 = 0 ;
31318 PyObject * obj1 = 0 ;
31319 char * kwnames[] = {
31320 (char *) "self",(char *) "data", NULL
31321 };
31322
31323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31325 if (!SWIG_IsOK(res1)) {
31326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31327 }
31328 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31329 arg2 = obj1;
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 {
31337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31338 }
31339 return resultobj;
31340 fail:
31341 return NULL;
31342 }
31343
31344
31345 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31346 PyObject *obj;
31347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31348 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31349 return SWIG_Py_Void();
31350 }
31351
31352 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31353 return SWIG_Python_InitShadowInstance(args);
31354 }
31355
31356 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31357 PyObject *resultobj = 0;
31358 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31359 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31360 wxPyDataObjectSimple *result = 0 ;
31361 void *argp1 = 0 ;
31362 int res1 = 0 ;
31363 PyObject * obj0 = 0 ;
31364 char * kwnames[] = {
31365 (char *) "format", NULL
31366 };
31367
31368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31369 if (obj0) {
31370 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31371 if (!SWIG_IsOK(res1)) {
31372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31373 }
31374 if (!argp1) {
31375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31376 }
31377 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31378 }
31379 {
31380 PyThreadState* __tstate = wxPyBeginAllowThreads();
31381 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31382 wxPyEndAllowThreads(__tstate);
31383 if (PyErr_Occurred()) SWIG_fail;
31384 }
31385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31386 return resultobj;
31387 fail:
31388 return NULL;
31389 }
31390
31391
31392 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31393 PyObject *resultobj = 0;
31394 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31395 PyObject *arg2 = (PyObject *) 0 ;
31396 PyObject *arg3 = (PyObject *) 0 ;
31397 void *argp1 = 0 ;
31398 int res1 = 0 ;
31399 PyObject * obj0 = 0 ;
31400 PyObject * obj1 = 0 ;
31401 PyObject * obj2 = 0 ;
31402 char * kwnames[] = {
31403 (char *) "self",(char *) "self",(char *) "_class", NULL
31404 };
31405
31406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31408 if (!SWIG_IsOK(res1)) {
31409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31410 }
31411 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31412 arg2 = obj1;
31413 arg3 = obj2;
31414 {
31415 PyThreadState* __tstate = wxPyBeginAllowThreads();
31416 (arg1)->_setCallbackInfo(arg2,arg3);
31417 wxPyEndAllowThreads(__tstate);
31418 if (PyErr_Occurred()) SWIG_fail;
31419 }
31420 resultobj = SWIG_Py_Void();
31421 return resultobj;
31422 fail:
31423 return NULL;
31424 }
31425
31426
31427 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31428 PyObject *obj;
31429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31430 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31431 return SWIG_Py_Void();
31432 }
31433
31434 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31435 return SWIG_Python_InitShadowInstance(args);
31436 }
31437
31438 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31439 PyObject *resultobj = 0;
31440 wxDataObjectComposite *result = 0 ;
31441
31442 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj = 0;
31458 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31459 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31460 bool arg3 = (bool) false ;
31461 void *argp1 = 0 ;
31462 int res1 = 0 ;
31463 int res2 = 0 ;
31464 bool val3 ;
31465 int ecode3 = 0 ;
31466 PyObject * obj0 = 0 ;
31467 PyObject * obj1 = 0 ;
31468 PyObject * obj2 = 0 ;
31469 char * kwnames[] = {
31470 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31471 };
31472
31473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31475 if (!SWIG_IsOK(res1)) {
31476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31477 }
31478 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31479 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31480 if (!SWIG_IsOK(res2)) {
31481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31482 }
31483 if (obj2) {
31484 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31485 if (!SWIG_IsOK(ecode3)) {
31486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31487 }
31488 arg3 = static_cast< bool >(val3);
31489 }
31490 {
31491 PyThreadState* __tstate = wxPyBeginAllowThreads();
31492 (arg1)->Add(arg2,arg3);
31493 wxPyEndAllowThreads(__tstate);
31494 if (PyErr_Occurred()) SWIG_fail;
31495 }
31496 resultobj = SWIG_Py_Void();
31497 return resultobj;
31498 fail:
31499 return NULL;
31500 }
31501
31502
31503 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31504 PyObject *resultobj = 0;
31505 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31506 SwigValueWrapper<wxDataFormat > result;
31507 void *argp1 = 0 ;
31508 int res1 = 0 ;
31509 PyObject *swig_obj[1] ;
31510
31511 if (!args) SWIG_fail;
31512 swig_obj[0] = args;
31513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31514 if (!SWIG_IsOK(res1)) {
31515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31516 }
31517 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31518 {
31519 PyThreadState* __tstate = wxPyBeginAllowThreads();
31520 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31521 wxPyEndAllowThreads(__tstate);
31522 if (PyErr_Occurred()) SWIG_fail;
31523 }
31524 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31525 return resultobj;
31526 fail:
31527 return NULL;
31528 }
31529
31530
31531 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31532 PyObject *obj;
31533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31534 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31535 return SWIG_Py_Void();
31536 }
31537
31538 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31539 return SWIG_Python_InitShadowInstance(args);
31540 }
31541
31542 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = 0;
31544 wxString const &arg1_defvalue = wxPyEmptyString ;
31545 wxString *arg1 = (wxString *) &arg1_defvalue ;
31546 wxTextDataObject *result = 0 ;
31547 bool temp1 = false ;
31548 PyObject * obj0 = 0 ;
31549 char * kwnames[] = {
31550 (char *) "text", NULL
31551 };
31552
31553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31554 if (obj0) {
31555 {
31556 arg1 = wxString_in_helper(obj0);
31557 if (arg1 == NULL) SWIG_fail;
31558 temp1 = true;
31559 }
31560 }
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31568 {
31569 if (temp1)
31570 delete arg1;
31571 }
31572 return resultobj;
31573 fail:
31574 {
31575 if (temp1)
31576 delete arg1;
31577 }
31578 return NULL;
31579 }
31580
31581
31582 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31583 PyObject *resultobj = 0;
31584 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31585 size_t result;
31586 void *argp1 = 0 ;
31587 int res1 = 0 ;
31588 PyObject *swig_obj[1] ;
31589
31590 if (!args) SWIG_fail;
31591 swig_obj[0] = args;
31592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31593 if (!SWIG_IsOK(res1)) {
31594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31595 }
31596 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31597 {
31598 PyThreadState* __tstate = wxPyBeginAllowThreads();
31599 result = (size_t)(arg1)->GetTextLength();
31600 wxPyEndAllowThreads(__tstate);
31601 if (PyErr_Occurred()) SWIG_fail;
31602 }
31603 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31604 return resultobj;
31605 fail:
31606 return NULL;
31607 }
31608
31609
31610 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31611 PyObject *resultobj = 0;
31612 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31613 wxString result;
31614 void *argp1 = 0 ;
31615 int res1 = 0 ;
31616 PyObject *swig_obj[1] ;
31617
31618 if (!args) SWIG_fail;
31619 swig_obj[0] = args;
31620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31621 if (!SWIG_IsOK(res1)) {
31622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31623 }
31624 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31625 {
31626 PyThreadState* __tstate = wxPyBeginAllowThreads();
31627 result = (arg1)->GetText();
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 {
31632 #if wxUSE_UNICODE
31633 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31634 #else
31635 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31636 #endif
31637 }
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31645 PyObject *resultobj = 0;
31646 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31647 wxString *arg2 = 0 ;
31648 void *argp1 = 0 ;
31649 int res1 = 0 ;
31650 bool temp2 = false ;
31651 PyObject * obj0 = 0 ;
31652 PyObject * obj1 = 0 ;
31653 char * kwnames[] = {
31654 (char *) "self",(char *) "text", NULL
31655 };
31656
31657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31659 if (!SWIG_IsOK(res1)) {
31660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31661 }
31662 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31663 {
31664 arg2 = wxString_in_helper(obj1);
31665 if (arg2 == NULL) SWIG_fail;
31666 temp2 = true;
31667 }
31668 {
31669 PyThreadState* __tstate = wxPyBeginAllowThreads();
31670 (arg1)->SetText((wxString const &)*arg2);
31671 wxPyEndAllowThreads(__tstate);
31672 if (PyErr_Occurred()) SWIG_fail;
31673 }
31674 resultobj = SWIG_Py_Void();
31675 {
31676 if (temp2)
31677 delete arg2;
31678 }
31679 return resultobj;
31680 fail:
31681 {
31682 if (temp2)
31683 delete arg2;
31684 }
31685 return NULL;
31686 }
31687
31688
31689 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31690 PyObject *obj;
31691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31692 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31693 return SWIG_Py_Void();
31694 }
31695
31696 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31697 return SWIG_Python_InitShadowInstance(args);
31698 }
31699
31700 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31701 PyObject *resultobj = 0;
31702 wxString const &arg1_defvalue = wxPyEmptyString ;
31703 wxString *arg1 = (wxString *) &arg1_defvalue ;
31704 wxPyTextDataObject *result = 0 ;
31705 bool temp1 = false ;
31706 PyObject * obj0 = 0 ;
31707 char * kwnames[] = {
31708 (char *) "text", NULL
31709 };
31710
31711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31712 if (obj0) {
31713 {
31714 arg1 = wxString_in_helper(obj0);
31715 if (arg1 == NULL) SWIG_fail;
31716 temp1 = true;
31717 }
31718 }
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31722 wxPyEndAllowThreads(__tstate);
31723 if (PyErr_Occurred()) SWIG_fail;
31724 }
31725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31726 {
31727 if (temp1)
31728 delete arg1;
31729 }
31730 return resultobj;
31731 fail:
31732 {
31733 if (temp1)
31734 delete arg1;
31735 }
31736 return NULL;
31737 }
31738
31739
31740 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31741 PyObject *resultobj = 0;
31742 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31743 PyObject *arg2 = (PyObject *) 0 ;
31744 PyObject *arg3 = (PyObject *) 0 ;
31745 void *argp1 = 0 ;
31746 int res1 = 0 ;
31747 PyObject * obj0 = 0 ;
31748 PyObject * obj1 = 0 ;
31749 PyObject * obj2 = 0 ;
31750 char * kwnames[] = {
31751 (char *) "self",(char *) "self",(char *) "_class", NULL
31752 };
31753
31754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31756 if (!SWIG_IsOK(res1)) {
31757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31758 }
31759 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31760 arg2 = obj1;
31761 arg3 = obj2;
31762 {
31763 PyThreadState* __tstate = wxPyBeginAllowThreads();
31764 (arg1)->_setCallbackInfo(arg2,arg3);
31765 wxPyEndAllowThreads(__tstate);
31766 if (PyErr_Occurred()) SWIG_fail;
31767 }
31768 resultobj = SWIG_Py_Void();
31769 return resultobj;
31770 fail:
31771 return NULL;
31772 }
31773
31774
31775 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31776 PyObject *obj;
31777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31778 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31779 return SWIG_Py_Void();
31780 }
31781
31782 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31783 return SWIG_Python_InitShadowInstance(args);
31784 }
31785
31786 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31787 PyObject *resultobj = 0;
31788 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31789 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31790 wxBitmapDataObject *result = 0 ;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 PyObject * obj0 = 0 ;
31794 char * kwnames[] = {
31795 (char *) "bitmap", NULL
31796 };
31797
31798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31799 if (obj0) {
31800 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31801 if (!SWIG_IsOK(res1)) {
31802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31803 }
31804 if (!argp1) {
31805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31806 }
31807 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31808 }
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31812 wxPyEndAllowThreads(__tstate);
31813 if (PyErr_Occurred()) SWIG_fail;
31814 }
31815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31816 return resultobj;
31817 fail:
31818 return NULL;
31819 }
31820
31821
31822 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31823 PyObject *resultobj = 0;
31824 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31825 wxBitmap result;
31826 void *argp1 = 0 ;
31827 int res1 = 0 ;
31828 PyObject *swig_obj[1] ;
31829
31830 if (!args) SWIG_fail;
31831 swig_obj[0] = args;
31832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31833 if (!SWIG_IsOK(res1)) {
31834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31835 }
31836 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31837 {
31838 PyThreadState* __tstate = wxPyBeginAllowThreads();
31839 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31840 wxPyEndAllowThreads(__tstate);
31841 if (PyErr_Occurred()) SWIG_fail;
31842 }
31843 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31844 return resultobj;
31845 fail:
31846 return NULL;
31847 }
31848
31849
31850 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31851 PyObject *resultobj = 0;
31852 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31853 wxBitmap *arg2 = 0 ;
31854 void *argp1 = 0 ;
31855 int res1 = 0 ;
31856 void *argp2 = 0 ;
31857 int res2 = 0 ;
31858 PyObject * obj0 = 0 ;
31859 PyObject * obj1 = 0 ;
31860 char * kwnames[] = {
31861 (char *) "self",(char *) "bitmap", NULL
31862 };
31863
31864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31866 if (!SWIG_IsOK(res1)) {
31867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31868 }
31869 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31870 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31871 if (!SWIG_IsOK(res2)) {
31872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31873 }
31874 if (!argp2) {
31875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31876 }
31877 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31878 {
31879 PyThreadState* __tstate = wxPyBeginAllowThreads();
31880 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31881 wxPyEndAllowThreads(__tstate);
31882 if (PyErr_Occurred()) SWIG_fail;
31883 }
31884 resultobj = SWIG_Py_Void();
31885 return resultobj;
31886 fail:
31887 return NULL;
31888 }
31889
31890
31891 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31892 PyObject *obj;
31893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31894 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31895 return SWIG_Py_Void();
31896 }
31897
31898 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31899 return SWIG_Python_InitShadowInstance(args);
31900 }
31901
31902 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31903 PyObject *resultobj = 0;
31904 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31905 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31906 wxPyBitmapDataObject *result = 0 ;
31907 void *argp1 = 0 ;
31908 int res1 = 0 ;
31909 PyObject * obj0 = 0 ;
31910 char * kwnames[] = {
31911 (char *) "bitmap", NULL
31912 };
31913
31914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31915 if (obj0) {
31916 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31919 }
31920 if (!argp1) {
31921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31922 }
31923 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31924 }
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31939 PyObject *resultobj = 0;
31940 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31941 PyObject *arg2 = (PyObject *) 0 ;
31942 PyObject *arg3 = (PyObject *) 0 ;
31943 void *argp1 = 0 ;
31944 int res1 = 0 ;
31945 PyObject * obj0 = 0 ;
31946 PyObject * obj1 = 0 ;
31947 PyObject * obj2 = 0 ;
31948 char * kwnames[] = {
31949 (char *) "self",(char *) "self",(char *) "_class", NULL
31950 };
31951
31952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31954 if (!SWIG_IsOK(res1)) {
31955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31956 }
31957 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31958 arg2 = obj1;
31959 arg3 = obj2;
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 (arg1)->_setCallbackInfo(arg2,arg3);
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 resultobj = SWIG_Py_Void();
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31974 PyObject *obj;
31975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31976 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31977 return SWIG_Py_Void();
31978 }
31979
31980 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31981 return SWIG_Python_InitShadowInstance(args);
31982 }
31983
31984 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31985 PyObject *resultobj = 0;
31986 wxFileDataObject *result = 0 ;
31987
31988 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31989 {
31990 PyThreadState* __tstate = wxPyBeginAllowThreads();
31991 result = (wxFileDataObject *)new wxFileDataObject();
31992 wxPyEndAllowThreads(__tstate);
31993 if (PyErr_Occurred()) SWIG_fail;
31994 }
31995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32003 PyObject *resultobj = 0;
32004 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32005 wxArrayString *result = 0 ;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 PyObject *swig_obj[1] ;
32009
32010 if (!args) SWIG_fail;
32011 swig_obj[0] = args;
32012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32015 }
32016 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 {
32020 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32021 result = (wxArrayString *) &_result_ref;
32022 }
32023 wxPyEndAllowThreads(__tstate);
32024 if (PyErr_Occurred()) SWIG_fail;
32025 }
32026 {
32027 resultobj = wxArrayString2PyList_helper(*result);
32028 }
32029 return resultobj;
32030 fail:
32031 return NULL;
32032 }
32033
32034
32035 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32036 PyObject *resultobj = 0;
32037 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32038 wxString *arg2 = 0 ;
32039 void *argp1 = 0 ;
32040 int res1 = 0 ;
32041 bool temp2 = false ;
32042 PyObject * obj0 = 0 ;
32043 PyObject * obj1 = 0 ;
32044 char * kwnames[] = {
32045 (char *) "self",(char *) "filename", NULL
32046 };
32047
32048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
32049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32050 if (!SWIG_IsOK(res1)) {
32051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32052 }
32053 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32054 {
32055 arg2 = wxString_in_helper(obj1);
32056 if (arg2 == NULL) SWIG_fail;
32057 temp2 = true;
32058 }
32059 {
32060 PyThreadState* __tstate = wxPyBeginAllowThreads();
32061 (arg1)->AddFile((wxString const &)*arg2);
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 resultobj = SWIG_Py_Void();
32066 {
32067 if (temp2)
32068 delete arg2;
32069 }
32070 return resultobj;
32071 fail:
32072 {
32073 if (temp2)
32074 delete arg2;
32075 }
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32081 PyObject *obj;
32082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32083 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
32084 return SWIG_Py_Void();
32085 }
32086
32087 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32088 return SWIG_Python_InitShadowInstance(args);
32089 }
32090
32091 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32092 PyObject *resultobj = 0;
32093 wxDataFormat *arg1 = 0 ;
32094 wxCustomDataObject *result = 0 ;
32095 void *argp1 = 0 ;
32096 int res1 = 0 ;
32097
32098 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32100 if (!SWIG_IsOK(res1)) {
32101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32102 }
32103 if (!argp1) {
32104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32105 }
32106 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32107 {
32108 PyThreadState* __tstate = wxPyBeginAllowThreads();
32109 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
32110 wxPyEndAllowThreads(__tstate);
32111 if (PyErr_Occurred()) SWIG_fail;
32112 }
32113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32114 return resultobj;
32115 fail:
32116 return NULL;
32117 }
32118
32119
32120 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32121 PyObject *resultobj = 0;
32122 wxString *arg1 = 0 ;
32123 wxCustomDataObject *result = 0 ;
32124 bool temp1 = false ;
32125
32126 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32127 {
32128 arg1 = wxString_in_helper(swig_obj[0]);
32129 if (arg1 == NULL) SWIG_fail;
32130 temp1 = true;
32131 }
32132 {
32133 PyThreadState* __tstate = wxPyBeginAllowThreads();
32134 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32135 wxPyEndAllowThreads(__tstate);
32136 if (PyErr_Occurred()) SWIG_fail;
32137 }
32138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32139 {
32140 if (temp1)
32141 delete arg1;
32142 }
32143 return resultobj;
32144 fail:
32145 {
32146 if (temp1)
32147 delete arg1;
32148 }
32149 return NULL;
32150 }
32151
32152
32153 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32154 PyObject *resultobj = 0;
32155 wxCustomDataObject *result = 0 ;
32156
32157 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32158 {
32159 PyThreadState* __tstate = wxPyBeginAllowThreads();
32160 result = (wxCustomDataObject *)new wxCustomDataObject();
32161 wxPyEndAllowThreads(__tstate);
32162 if (PyErr_Occurred()) SWIG_fail;
32163 }
32164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32165 return resultobj;
32166 fail:
32167 return NULL;
32168 }
32169
32170
32171 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32172 int argc;
32173 PyObject *argv[2];
32174
32175 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32176 --argc;
32177 if (argc == 0) {
32178 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32179 }
32180 if (argc == 1) {
32181 int _v = 0;
32182 {
32183 {
32184 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32185 }
32186 }
32187 if (!_v) goto check_2;
32188 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32189 }
32190 check_2:
32191
32192 if (argc == 1) {
32193 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32194 }
32195
32196 fail:
32197 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32198 return NULL;
32199 }
32200
32201
32202 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32203 PyObject *resultobj = 0;
32204 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32205 PyObject *arg2 = (PyObject *) 0 ;
32206 bool result;
32207 void *argp1 = 0 ;
32208 int res1 = 0 ;
32209 PyObject * obj0 = 0 ;
32210 PyObject * obj1 = 0 ;
32211 char * kwnames[] = {
32212 (char *) "self",(char *) "data", NULL
32213 };
32214
32215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32219 }
32220 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32221 arg2 = obj1;
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 {
32229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32230 }
32231 return resultobj;
32232 fail:
32233 return NULL;
32234 }
32235
32236
32237 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32238 PyObject *resultobj = 0;
32239 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32240 size_t result;
32241 void *argp1 = 0 ;
32242 int res1 = 0 ;
32243 PyObject *swig_obj[1] ;
32244
32245 if (!args) SWIG_fail;
32246 swig_obj[0] = args;
32247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32248 if (!SWIG_IsOK(res1)) {
32249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32250 }
32251 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32252 {
32253 PyThreadState* __tstate = wxPyBeginAllowThreads();
32254 result = (size_t)(arg1)->GetSize();
32255 wxPyEndAllowThreads(__tstate);
32256 if (PyErr_Occurred()) SWIG_fail;
32257 }
32258 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32259 return resultobj;
32260 fail:
32261 return NULL;
32262 }
32263
32264
32265 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32266 PyObject *resultobj = 0;
32267 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32268 PyObject *result = 0 ;
32269 void *argp1 = 0 ;
32270 int res1 = 0 ;
32271 PyObject *swig_obj[1] ;
32272
32273 if (!args) SWIG_fail;
32274 swig_obj[0] = args;
32275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32276 if (!SWIG_IsOK(res1)) {
32277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32278 }
32279 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32280 {
32281 PyThreadState* __tstate = wxPyBeginAllowThreads();
32282 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32283 wxPyEndAllowThreads(__tstate);
32284 if (PyErr_Occurred()) SWIG_fail;
32285 }
32286 resultobj = result;
32287 return resultobj;
32288 fail:
32289 return NULL;
32290 }
32291
32292
32293 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32294 PyObject *obj;
32295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32296 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32297 return SWIG_Py_Void();
32298 }
32299
32300 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32301 return SWIG_Python_InitShadowInstance(args);
32302 }
32303
32304 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32305 PyObject *resultobj = 0;
32306 wxURLDataObject *result = 0 ;
32307
32308 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 result = (wxURLDataObject *)new wxURLDataObject();
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 PyObject *resultobj = 0;
32324 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32325 wxString result;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 PyObject *swig_obj[1] ;
32329
32330 if (!args) SWIG_fail;
32331 swig_obj[0] = args;
32332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32335 }
32336 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = (arg1)->GetURL();
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 {
32344 #if wxUSE_UNICODE
32345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32346 #else
32347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32348 #endif
32349 }
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj = 0;
32358 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32359 wxString *arg2 = 0 ;
32360 void *argp1 = 0 ;
32361 int res1 = 0 ;
32362 bool temp2 = false ;
32363 PyObject * obj0 = 0 ;
32364 PyObject * obj1 = 0 ;
32365 char * kwnames[] = {
32366 (char *) "self",(char *) "url", NULL
32367 };
32368
32369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32371 if (!SWIG_IsOK(res1)) {
32372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32373 }
32374 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32375 {
32376 arg2 = wxString_in_helper(obj1);
32377 if (arg2 == NULL) SWIG_fail;
32378 temp2 = true;
32379 }
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 (arg1)->SetURL((wxString const &)*arg2);
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 resultobj = SWIG_Py_Void();
32387 {
32388 if (temp2)
32389 delete arg2;
32390 }
32391 return resultobj;
32392 fail:
32393 {
32394 if (temp2)
32395 delete arg2;
32396 }
32397 return NULL;
32398 }
32399
32400
32401 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32402 PyObject *obj;
32403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32404 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32405 return SWIG_Py_Void();
32406 }
32407
32408 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32409 return SWIG_Python_InitShadowInstance(args);
32410 }
32411
32412 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32413 PyObject *resultobj = 0;
32414 wxMetafileDataObject *result = 0 ;
32415
32416 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32417 {
32418 PyThreadState* __tstate = wxPyBeginAllowThreads();
32419 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32431 PyObject *resultobj = 0;
32432 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32433 wxMetafile *arg2 = 0 ;
32434 void *argp1 = 0 ;
32435 int res1 = 0 ;
32436 void *argp2 = 0 ;
32437 int res2 = 0 ;
32438 PyObject * obj0 = 0 ;
32439 PyObject * obj1 = 0 ;
32440 char * kwnames[] = {
32441 (char *) "self",(char *) "metafile", NULL
32442 };
32443
32444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32446 if (!SWIG_IsOK(res1)) {
32447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32448 }
32449 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32451 if (!SWIG_IsOK(res2)) {
32452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32453 }
32454 if (!argp2) {
32455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32456 }
32457 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32458 {
32459 PyThreadState* __tstate = wxPyBeginAllowThreads();
32460 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32461 wxPyEndAllowThreads(__tstate);
32462 if (PyErr_Occurred()) SWIG_fail;
32463 }
32464 resultobj = SWIG_Py_Void();
32465 return resultobj;
32466 fail:
32467 return NULL;
32468 }
32469
32470
32471 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32472 PyObject *resultobj = 0;
32473 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32474 wxMetafile result;
32475 void *argp1 = 0 ;
32476 int res1 = 0 ;
32477 PyObject *swig_obj[1] ;
32478
32479 if (!args) SWIG_fail;
32480 swig_obj[0] = args;
32481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32482 if (!SWIG_IsOK(res1)) {
32483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32484 }
32485 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32486 {
32487 PyThreadState* __tstate = wxPyBeginAllowThreads();
32488 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32489 wxPyEndAllowThreads(__tstate);
32490 if (PyErr_Occurred()) SWIG_fail;
32491 }
32492 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32493 return resultobj;
32494 fail:
32495 return NULL;
32496 }
32497
32498
32499 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32500 PyObject *obj;
32501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32502 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32503 return SWIG_Py_Void();
32504 }
32505
32506 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32507 return SWIG_Python_InitShadowInstance(args);
32508 }
32509
32510 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32511 PyObject *resultobj = 0;
32512 wxDragResult arg1 ;
32513 bool result;
32514 int val1 ;
32515 int ecode1 = 0 ;
32516 PyObject * obj0 = 0 ;
32517 char * kwnames[] = {
32518 (char *) "res", NULL
32519 };
32520
32521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32522 ecode1 = SWIG_AsVal_int(obj0, &val1);
32523 if (!SWIG_IsOK(ecode1)) {
32524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32525 }
32526 arg1 = static_cast< wxDragResult >(val1);
32527 {
32528 PyThreadState* __tstate = wxPyBeginAllowThreads();
32529 result = (bool)wxIsDragResultOk(arg1);
32530 wxPyEndAllowThreads(__tstate);
32531 if (PyErr_Occurred()) SWIG_fail;
32532 }
32533 {
32534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32535 }
32536 return resultobj;
32537 fail:
32538 return NULL;
32539 }
32540
32541
32542 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32543 PyObject *resultobj = 0;
32544 wxWindow *arg1 = (wxWindow *) 0 ;
32545 wxCursor const &arg2_defvalue = wxNullCursor ;
32546 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32547 wxCursor const &arg3_defvalue = wxNullCursor ;
32548 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32549 wxCursor const &arg4_defvalue = wxNullCursor ;
32550 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32551 wxPyDropSource *result = 0 ;
32552 void *argp1 = 0 ;
32553 int res1 = 0 ;
32554 void *argp2 = 0 ;
32555 int res2 = 0 ;
32556 void *argp3 = 0 ;
32557 int res3 = 0 ;
32558 void *argp4 = 0 ;
32559 int res4 = 0 ;
32560 PyObject * obj0 = 0 ;
32561 PyObject * obj1 = 0 ;
32562 PyObject * obj2 = 0 ;
32563 PyObject * obj3 = 0 ;
32564 char * kwnames[] = {
32565 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32566 };
32567
32568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32570 if (!SWIG_IsOK(res1)) {
32571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32572 }
32573 arg1 = reinterpret_cast< wxWindow * >(argp1);
32574 if (obj1) {
32575 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32576 if (!SWIG_IsOK(res2)) {
32577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32578 }
32579 if (!argp2) {
32580 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32581 }
32582 arg2 = reinterpret_cast< wxCursor * >(argp2);
32583 }
32584 if (obj2) {
32585 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32586 if (!SWIG_IsOK(res3)) {
32587 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32588 }
32589 if (!argp3) {
32590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32591 }
32592 arg3 = reinterpret_cast< wxCursor * >(argp3);
32593 }
32594 if (obj3) {
32595 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32596 if (!SWIG_IsOK(res4)) {
32597 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32598 }
32599 if (!argp4) {
32600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32601 }
32602 arg4 = reinterpret_cast< wxCursor * >(argp4);
32603 }
32604 {
32605 PyThreadState* __tstate = wxPyBeginAllowThreads();
32606 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32607 wxPyEndAllowThreads(__tstate);
32608 if (PyErr_Occurred()) SWIG_fail;
32609 }
32610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32611 return resultobj;
32612 fail:
32613 return NULL;
32614 }
32615
32616
32617 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32618 PyObject *resultobj = 0;
32619 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32620 PyObject *arg2 = (PyObject *) 0 ;
32621 PyObject *arg3 = (PyObject *) 0 ;
32622 int arg4 ;
32623 void *argp1 = 0 ;
32624 int res1 = 0 ;
32625 int val4 ;
32626 int ecode4 = 0 ;
32627 PyObject * obj0 = 0 ;
32628 PyObject * obj1 = 0 ;
32629 PyObject * obj2 = 0 ;
32630 PyObject * obj3 = 0 ;
32631 char * kwnames[] = {
32632 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32633 };
32634
32635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32637 if (!SWIG_IsOK(res1)) {
32638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32639 }
32640 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32641 arg2 = obj1;
32642 arg3 = obj2;
32643 ecode4 = SWIG_AsVal_int(obj3, &val4);
32644 if (!SWIG_IsOK(ecode4)) {
32645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32646 }
32647 arg4 = static_cast< int >(val4);
32648 {
32649 PyThreadState* __tstate = wxPyBeginAllowThreads();
32650 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32651 wxPyEndAllowThreads(__tstate);
32652 if (PyErr_Occurred()) SWIG_fail;
32653 }
32654 resultobj = SWIG_Py_Void();
32655 return resultobj;
32656 fail:
32657 return NULL;
32658 }
32659
32660
32661 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32662 PyObject *resultobj = 0;
32663 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32664 void *argp1 = 0 ;
32665 int res1 = 0 ;
32666 PyObject *swig_obj[1] ;
32667
32668 if (!args) SWIG_fail;
32669 swig_obj[0] = args;
32670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32671 if (!SWIG_IsOK(res1)) {
32672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32673 }
32674 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32675 {
32676 PyThreadState* __tstate = wxPyBeginAllowThreads();
32677 delete arg1;
32678
32679 wxPyEndAllowThreads(__tstate);
32680 if (PyErr_Occurred()) SWIG_fail;
32681 }
32682 resultobj = SWIG_Py_Void();
32683 return resultobj;
32684 fail:
32685 return NULL;
32686 }
32687
32688
32689 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32690 PyObject *resultobj = 0;
32691 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32692 wxDataObject *arg2 = 0 ;
32693 void *argp1 = 0 ;
32694 int res1 = 0 ;
32695 void *argp2 = 0 ;
32696 int res2 = 0 ;
32697 PyObject * obj0 = 0 ;
32698 PyObject * obj1 = 0 ;
32699 char * kwnames[] = {
32700 (char *) "self",(char *) "data", NULL
32701 };
32702
32703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32705 if (!SWIG_IsOK(res1)) {
32706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32707 }
32708 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32710 if (!SWIG_IsOK(res2)) {
32711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32712 }
32713 if (!argp2) {
32714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32715 }
32716 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32717 {
32718 PyThreadState* __tstate = wxPyBeginAllowThreads();
32719 (arg1)->SetData(*arg2);
32720 wxPyEndAllowThreads(__tstate);
32721 if (PyErr_Occurred()) SWIG_fail;
32722 }
32723 resultobj = SWIG_Py_Void();
32724 return resultobj;
32725 fail:
32726 return NULL;
32727 }
32728
32729
32730 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32731 PyObject *resultobj = 0;
32732 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32733 wxDataObject *result = 0 ;
32734 void *argp1 = 0 ;
32735 int res1 = 0 ;
32736 PyObject *swig_obj[1] ;
32737
32738 if (!args) SWIG_fail;
32739 swig_obj[0] = args;
32740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32741 if (!SWIG_IsOK(res1)) {
32742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32743 }
32744 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32745 {
32746 PyThreadState* __tstate = wxPyBeginAllowThreads();
32747 result = (wxDataObject *)(arg1)->GetDataObject();
32748 wxPyEndAllowThreads(__tstate);
32749 if (PyErr_Occurred()) SWIG_fail;
32750 }
32751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32752 return resultobj;
32753 fail:
32754 return NULL;
32755 }
32756
32757
32758 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32759 PyObject *resultobj = 0;
32760 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32761 wxDragResult arg2 ;
32762 wxCursor *arg3 = 0 ;
32763 void *argp1 = 0 ;
32764 int res1 = 0 ;
32765 int val2 ;
32766 int ecode2 = 0 ;
32767 void *argp3 = 0 ;
32768 int res3 = 0 ;
32769 PyObject * obj0 = 0 ;
32770 PyObject * obj1 = 0 ;
32771 PyObject * obj2 = 0 ;
32772 char * kwnames[] = {
32773 (char *) "self",(char *) "res",(char *) "cursor", NULL
32774 };
32775
32776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32778 if (!SWIG_IsOK(res1)) {
32779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32780 }
32781 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32782 ecode2 = SWIG_AsVal_int(obj1, &val2);
32783 if (!SWIG_IsOK(ecode2)) {
32784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32785 }
32786 arg2 = static_cast< wxDragResult >(val2);
32787 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32788 if (!SWIG_IsOK(res3)) {
32789 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32790 }
32791 if (!argp3) {
32792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32793 }
32794 arg3 = reinterpret_cast< wxCursor * >(argp3);
32795 {
32796 PyThreadState* __tstate = wxPyBeginAllowThreads();
32797 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32798 wxPyEndAllowThreads(__tstate);
32799 if (PyErr_Occurred()) SWIG_fail;
32800 }
32801 resultobj = SWIG_Py_Void();
32802 return resultobj;
32803 fail:
32804 return NULL;
32805 }
32806
32807
32808 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32809 PyObject *resultobj = 0;
32810 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32811 int arg2 = (int) wxDrag_CopyOnly ;
32812 wxDragResult result;
32813 void *argp1 = 0 ;
32814 int res1 = 0 ;
32815 int val2 ;
32816 int ecode2 = 0 ;
32817 PyObject * obj0 = 0 ;
32818 PyObject * obj1 = 0 ;
32819 char * kwnames[] = {
32820 (char *) "self",(char *) "flags", NULL
32821 };
32822
32823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32825 if (!SWIG_IsOK(res1)) {
32826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32827 }
32828 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32829 if (obj1) {
32830 ecode2 = SWIG_AsVal_int(obj1, &val2);
32831 if (!SWIG_IsOK(ecode2)) {
32832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32833 }
32834 arg2 = static_cast< int >(val2);
32835 }
32836 {
32837 PyThreadState* __tstate = wxPyBeginAllowThreads();
32838 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32839 wxPyEndAllowThreads(__tstate);
32840 if (PyErr_Occurred()) SWIG_fail;
32841 }
32842 resultobj = SWIG_From_int(static_cast< int >(result));
32843 return resultobj;
32844 fail:
32845 return NULL;
32846 }
32847
32848
32849 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32850 PyObject *resultobj = 0;
32851 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32852 wxDragResult arg2 ;
32853 bool result;
32854 void *argp1 = 0 ;
32855 int res1 = 0 ;
32856 int val2 ;
32857 int ecode2 = 0 ;
32858 PyObject * obj0 = 0 ;
32859 PyObject * obj1 = 0 ;
32860 char * kwnames[] = {
32861 (char *) "self",(char *) "effect", NULL
32862 };
32863
32864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32866 if (!SWIG_IsOK(res1)) {
32867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32868 }
32869 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32870 ecode2 = SWIG_AsVal_int(obj1, &val2);
32871 if (!SWIG_IsOK(ecode2)) {
32872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32873 }
32874 arg2 = static_cast< wxDragResult >(val2);
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 result = (bool)(arg1)->GiveFeedback(arg2);
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 {
32882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32883 }
32884 return resultobj;
32885 fail:
32886 return NULL;
32887 }
32888
32889
32890 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32891 PyObject *obj;
32892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32893 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32894 return SWIG_Py_Void();
32895 }
32896
32897 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32898 return SWIG_Python_InitShadowInstance(args);
32899 }
32900
32901 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32902 PyObject *resultobj = 0;
32903 wxDataObject *arg1 = (wxDataObject *) NULL ;
32904 wxPyDropTarget *result = 0 ;
32905 int res1 = 0 ;
32906 PyObject * obj0 = 0 ;
32907 char * kwnames[] = {
32908 (char *) "dataObject", NULL
32909 };
32910
32911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32912 if (obj0) {
32913 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32914 if (!SWIG_IsOK(res1)) {
32915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32916 }
32917 }
32918 {
32919 PyThreadState* __tstate = wxPyBeginAllowThreads();
32920 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32921 wxPyEndAllowThreads(__tstate);
32922 if (PyErr_Occurred()) SWIG_fail;
32923 }
32924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32925 return resultobj;
32926 fail:
32927 return NULL;
32928 }
32929
32930
32931 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32932 PyObject *resultobj = 0;
32933 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32934 PyObject *arg2 = (PyObject *) 0 ;
32935 PyObject *arg3 = (PyObject *) 0 ;
32936 void *argp1 = 0 ;
32937 int res1 = 0 ;
32938 PyObject * obj0 = 0 ;
32939 PyObject * obj1 = 0 ;
32940 PyObject * obj2 = 0 ;
32941 char * kwnames[] = {
32942 (char *) "self",(char *) "self",(char *) "_class", NULL
32943 };
32944
32945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32949 }
32950 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32951 arg2 = obj1;
32952 arg3 = obj2;
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 (arg1)->_setCallbackInfo(arg2,arg3);
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 resultobj = SWIG_Py_Void();
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32969 void *argp1 = 0 ;
32970 int res1 = 0 ;
32971 PyObject *swig_obj[1] ;
32972
32973 if (!args) SWIG_fail;
32974 swig_obj[0] = args;
32975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32976 if (!SWIG_IsOK(res1)) {
32977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32978 }
32979 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32980 {
32981 PyThreadState* __tstate = wxPyBeginAllowThreads();
32982 delete arg1;
32983
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 resultobj = SWIG_Py_Void();
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32995 PyObject *resultobj = 0;
32996 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32997 wxDataObject *result = 0 ;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 PyObject *swig_obj[1] ;
33001
33002 if (!args) SWIG_fail;
33003 swig_obj[0] = args;
33004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33007 }
33008 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33009 {
33010 PyThreadState* __tstate = wxPyBeginAllowThreads();
33011 result = (wxDataObject *)(arg1)->GetDataObject();
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33016 return resultobj;
33017 fail:
33018 return NULL;
33019 }
33020
33021
33022 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33023 PyObject *resultobj = 0;
33024 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33025 wxDataObject *arg2 = (wxDataObject *) 0 ;
33026 void *argp1 = 0 ;
33027 int res1 = 0 ;
33028 int res2 = 0 ;
33029 PyObject * obj0 = 0 ;
33030 PyObject * obj1 = 0 ;
33031 char * kwnames[] = {
33032 (char *) "self",(char *) "dataObject", NULL
33033 };
33034
33035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
33036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33037 if (!SWIG_IsOK(res1)) {
33038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33039 }
33040 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33041 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33042 if (!SWIG_IsOK(res2)) {
33043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
33044 }
33045 {
33046 PyThreadState* __tstate = wxPyBeginAllowThreads();
33047 (arg1)->SetDataObject(arg2);
33048 wxPyEndAllowThreads(__tstate);
33049 if (PyErr_Occurred()) SWIG_fail;
33050 }
33051 resultobj = SWIG_Py_Void();
33052 return resultobj;
33053 fail:
33054 return NULL;
33055 }
33056
33057
33058 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33059 PyObject *resultobj = 0;
33060 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33061 int arg2 ;
33062 int arg3 ;
33063 wxDragResult arg4 ;
33064 wxDragResult result;
33065 void *argp1 = 0 ;
33066 int res1 = 0 ;
33067 int val2 ;
33068 int ecode2 = 0 ;
33069 int val3 ;
33070 int ecode3 = 0 ;
33071 int val4 ;
33072 int ecode4 = 0 ;
33073 PyObject * obj0 = 0 ;
33074 PyObject * obj1 = 0 ;
33075 PyObject * obj2 = 0 ;
33076 PyObject * obj3 = 0 ;
33077 char * kwnames[] = {
33078 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33079 };
33080
33081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33083 if (!SWIG_IsOK(res1)) {
33084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33085 }
33086 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33087 ecode2 = SWIG_AsVal_int(obj1, &val2);
33088 if (!SWIG_IsOK(ecode2)) {
33089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33090 }
33091 arg2 = static_cast< int >(val2);
33092 ecode3 = SWIG_AsVal_int(obj2, &val3);
33093 if (!SWIG_IsOK(ecode3)) {
33094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33095 }
33096 arg3 = static_cast< int >(val3);
33097 ecode4 = SWIG_AsVal_int(obj3, &val4);
33098 if (!SWIG_IsOK(ecode4)) {
33099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33100 }
33101 arg4 = static_cast< wxDragResult >(val4);
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33105 wxPyEndAllowThreads(__tstate);
33106 if (PyErr_Occurred()) SWIG_fail;
33107 }
33108 resultobj = SWIG_From_int(static_cast< int >(result));
33109 return resultobj;
33110 fail:
33111 return NULL;
33112 }
33113
33114
33115 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33116 PyObject *resultobj = 0;
33117 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33118 int arg2 ;
33119 int arg3 ;
33120 wxDragResult arg4 ;
33121 wxDragResult result;
33122 void *argp1 = 0 ;
33123 int res1 = 0 ;
33124 int val2 ;
33125 int ecode2 = 0 ;
33126 int val3 ;
33127 int ecode3 = 0 ;
33128 int val4 ;
33129 int ecode4 = 0 ;
33130 PyObject * obj0 = 0 ;
33131 PyObject * obj1 = 0 ;
33132 PyObject * obj2 = 0 ;
33133 PyObject * obj3 = 0 ;
33134 char * kwnames[] = {
33135 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33136 };
33137
33138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33140 if (!SWIG_IsOK(res1)) {
33141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33142 }
33143 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33144 ecode2 = SWIG_AsVal_int(obj1, &val2);
33145 if (!SWIG_IsOK(ecode2)) {
33146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33147 }
33148 arg2 = static_cast< int >(val2);
33149 ecode3 = SWIG_AsVal_int(obj2, &val3);
33150 if (!SWIG_IsOK(ecode3)) {
33151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33152 }
33153 arg3 = static_cast< int >(val3);
33154 ecode4 = SWIG_AsVal_int(obj3, &val4);
33155 if (!SWIG_IsOK(ecode4)) {
33156 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33157 }
33158 arg4 = static_cast< wxDragResult >(val4);
33159 {
33160 PyThreadState* __tstate = wxPyBeginAllowThreads();
33161 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33162 wxPyEndAllowThreads(__tstate);
33163 if (PyErr_Occurred()) SWIG_fail;
33164 }
33165 resultobj = SWIG_From_int(static_cast< int >(result));
33166 return resultobj;
33167 fail:
33168 return NULL;
33169 }
33170
33171
33172 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33173 PyObject *resultobj = 0;
33174 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33175 void *argp1 = 0 ;
33176 int res1 = 0 ;
33177 PyObject *swig_obj[1] ;
33178
33179 if (!args) SWIG_fail;
33180 swig_obj[0] = args;
33181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33182 if (!SWIG_IsOK(res1)) {
33183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33184 }
33185 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33186 {
33187 PyThreadState* __tstate = wxPyBeginAllowThreads();
33188 (arg1)->OnLeave();
33189 wxPyEndAllowThreads(__tstate);
33190 if (PyErr_Occurred()) SWIG_fail;
33191 }
33192 resultobj = SWIG_Py_Void();
33193 return resultobj;
33194 fail:
33195 return NULL;
33196 }
33197
33198
33199 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33200 PyObject *resultobj = 0;
33201 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33202 int arg2 ;
33203 int arg3 ;
33204 bool result;
33205 void *argp1 = 0 ;
33206 int res1 = 0 ;
33207 int val2 ;
33208 int ecode2 = 0 ;
33209 int val3 ;
33210 int ecode3 = 0 ;
33211 PyObject * obj0 = 0 ;
33212 PyObject * obj1 = 0 ;
33213 PyObject * obj2 = 0 ;
33214 char * kwnames[] = {
33215 (char *) "self",(char *) "x",(char *) "y", NULL
33216 };
33217
33218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33220 if (!SWIG_IsOK(res1)) {
33221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33222 }
33223 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33224 ecode2 = SWIG_AsVal_int(obj1, &val2);
33225 if (!SWIG_IsOK(ecode2)) {
33226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33227 }
33228 arg2 = static_cast< int >(val2);
33229 ecode3 = SWIG_AsVal_int(obj2, &val3);
33230 if (!SWIG_IsOK(ecode3)) {
33231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33232 }
33233 arg3 = static_cast< int >(val3);
33234 {
33235 PyThreadState* __tstate = wxPyBeginAllowThreads();
33236 result = (bool)(arg1)->OnDrop(arg2,arg3);
33237 wxPyEndAllowThreads(__tstate);
33238 if (PyErr_Occurred()) SWIG_fail;
33239 }
33240 {
33241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33242 }
33243 return resultobj;
33244 fail:
33245 return NULL;
33246 }
33247
33248
33249 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33250 PyObject *resultobj = 0;
33251 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33252 bool result;
33253 void *argp1 = 0 ;
33254 int res1 = 0 ;
33255 PyObject *swig_obj[1] ;
33256
33257 if (!args) SWIG_fail;
33258 swig_obj[0] = args;
33259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33260 if (!SWIG_IsOK(res1)) {
33261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33262 }
33263 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33264 {
33265 PyThreadState* __tstate = wxPyBeginAllowThreads();
33266 result = (bool)(arg1)->GetData();
33267 wxPyEndAllowThreads(__tstate);
33268 if (PyErr_Occurred()) SWIG_fail;
33269 }
33270 {
33271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33272 }
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33280 PyObject *resultobj = 0;
33281 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33282 wxDragResult arg2 ;
33283 void *argp1 = 0 ;
33284 int res1 = 0 ;
33285 int val2 ;
33286 int ecode2 = 0 ;
33287 PyObject * obj0 = 0 ;
33288 PyObject * obj1 = 0 ;
33289 char * kwnames[] = {
33290 (char *) "self",(char *) "action", NULL
33291 };
33292
33293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33295 if (!SWIG_IsOK(res1)) {
33296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33297 }
33298 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33299 ecode2 = SWIG_AsVal_int(obj1, &val2);
33300 if (!SWIG_IsOK(ecode2)) {
33301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33302 }
33303 arg2 = static_cast< wxDragResult >(val2);
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 (arg1)->SetDefaultAction(arg2);
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 resultobj = SWIG_Py_Void();
33311 return resultobj;
33312 fail:
33313 return NULL;
33314 }
33315
33316
33317 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33318 PyObject *resultobj = 0;
33319 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33320 wxDragResult result;
33321 void *argp1 = 0 ;
33322 int res1 = 0 ;
33323 PyObject *swig_obj[1] ;
33324
33325 if (!args) SWIG_fail;
33326 swig_obj[0] = args;
33327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33328 if (!SWIG_IsOK(res1)) {
33329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33330 }
33331 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33332 {
33333 PyThreadState* __tstate = wxPyBeginAllowThreads();
33334 result = (wxDragResult)(arg1)->GetDefaultAction();
33335 wxPyEndAllowThreads(__tstate);
33336 if (PyErr_Occurred()) SWIG_fail;
33337 }
33338 resultobj = SWIG_From_int(static_cast< int >(result));
33339 return resultobj;
33340 fail:
33341 return NULL;
33342 }
33343
33344
33345 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33346 PyObject *obj;
33347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33348 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33349 return SWIG_Py_Void();
33350 }
33351
33352 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33353 return SWIG_Python_InitShadowInstance(args);
33354 }
33355
33356 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33357 PyObject *resultobj = 0;
33358 wxPyTextDropTarget *result = 0 ;
33359
33360 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33361 {
33362 PyThreadState* __tstate = wxPyBeginAllowThreads();
33363 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33364 wxPyEndAllowThreads(__tstate);
33365 if (PyErr_Occurred()) SWIG_fail;
33366 }
33367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33368 return resultobj;
33369 fail:
33370 return NULL;
33371 }
33372
33373
33374 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33375 PyObject *resultobj = 0;
33376 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33377 PyObject *arg2 = (PyObject *) 0 ;
33378 PyObject *arg3 = (PyObject *) 0 ;
33379 void *argp1 = 0 ;
33380 int res1 = 0 ;
33381 PyObject * obj0 = 0 ;
33382 PyObject * obj1 = 0 ;
33383 PyObject * obj2 = 0 ;
33384 char * kwnames[] = {
33385 (char *) "self",(char *) "self",(char *) "_class", NULL
33386 };
33387
33388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33390 if (!SWIG_IsOK(res1)) {
33391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33392 }
33393 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33394 arg2 = obj1;
33395 arg3 = obj2;
33396 {
33397 PyThreadState* __tstate = wxPyBeginAllowThreads();
33398 (arg1)->_setCallbackInfo(arg2,arg3);
33399 wxPyEndAllowThreads(__tstate);
33400 if (PyErr_Occurred()) SWIG_fail;
33401 }
33402 resultobj = SWIG_Py_Void();
33403 return resultobj;
33404 fail:
33405 return NULL;
33406 }
33407
33408
33409 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33410 PyObject *resultobj = 0;
33411 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33412 int arg2 ;
33413 int arg3 ;
33414 wxString *arg4 = 0 ;
33415 bool result;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 int val2 ;
33419 int ecode2 = 0 ;
33420 int val3 ;
33421 int ecode3 = 0 ;
33422 bool temp4 = false ;
33423 PyObject * obj0 = 0 ;
33424 PyObject * obj1 = 0 ;
33425 PyObject * obj2 = 0 ;
33426 PyObject * obj3 = 0 ;
33427 char * kwnames[] = {
33428 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33429 };
33430
33431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33433 if (!SWIG_IsOK(res1)) {
33434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33435 }
33436 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33437 ecode2 = SWIG_AsVal_int(obj1, &val2);
33438 if (!SWIG_IsOK(ecode2)) {
33439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33440 }
33441 arg2 = static_cast< int >(val2);
33442 ecode3 = SWIG_AsVal_int(obj2, &val3);
33443 if (!SWIG_IsOK(ecode3)) {
33444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33445 }
33446 arg3 = static_cast< int >(val3);
33447 {
33448 arg4 = wxString_in_helper(obj3);
33449 if (arg4 == NULL) SWIG_fail;
33450 temp4 = true;
33451 }
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33455 wxPyEndAllowThreads(__tstate);
33456 if (PyErr_Occurred()) SWIG_fail;
33457 }
33458 {
33459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33460 }
33461 {
33462 if (temp4)
33463 delete arg4;
33464 }
33465 return resultobj;
33466 fail:
33467 {
33468 if (temp4)
33469 delete arg4;
33470 }
33471 return NULL;
33472 }
33473
33474
33475 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33476 PyObject *resultobj = 0;
33477 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33478 int arg2 ;
33479 int arg3 ;
33480 wxDragResult arg4 ;
33481 wxDragResult result;
33482 void *argp1 = 0 ;
33483 int res1 = 0 ;
33484 int val2 ;
33485 int ecode2 = 0 ;
33486 int val3 ;
33487 int ecode3 = 0 ;
33488 int val4 ;
33489 int ecode4 = 0 ;
33490 PyObject * obj0 = 0 ;
33491 PyObject * obj1 = 0 ;
33492 PyObject * obj2 = 0 ;
33493 PyObject * obj3 = 0 ;
33494 char * kwnames[] = {
33495 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33496 };
33497
33498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33500 if (!SWIG_IsOK(res1)) {
33501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33502 }
33503 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33504 ecode2 = SWIG_AsVal_int(obj1, &val2);
33505 if (!SWIG_IsOK(ecode2)) {
33506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33507 }
33508 arg2 = static_cast< int >(val2);
33509 ecode3 = SWIG_AsVal_int(obj2, &val3);
33510 if (!SWIG_IsOK(ecode3)) {
33511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33512 }
33513 arg3 = static_cast< int >(val3);
33514 ecode4 = SWIG_AsVal_int(obj3, &val4);
33515 if (!SWIG_IsOK(ecode4)) {
33516 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33517 }
33518 arg4 = static_cast< wxDragResult >(val4);
33519 {
33520 PyThreadState* __tstate = wxPyBeginAllowThreads();
33521 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33522 wxPyEndAllowThreads(__tstate);
33523 if (PyErr_Occurred()) SWIG_fail;
33524 }
33525 resultobj = SWIG_From_int(static_cast< int >(result));
33526 return resultobj;
33527 fail:
33528 return NULL;
33529 }
33530
33531
33532 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33533 PyObject *resultobj = 0;
33534 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33535 int arg2 ;
33536 int arg3 ;
33537 wxDragResult arg4 ;
33538 wxDragResult result;
33539 void *argp1 = 0 ;
33540 int res1 = 0 ;
33541 int val2 ;
33542 int ecode2 = 0 ;
33543 int val3 ;
33544 int ecode3 = 0 ;
33545 int val4 ;
33546 int ecode4 = 0 ;
33547 PyObject * obj0 = 0 ;
33548 PyObject * obj1 = 0 ;
33549 PyObject * obj2 = 0 ;
33550 PyObject * obj3 = 0 ;
33551 char * kwnames[] = {
33552 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33553 };
33554
33555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33557 if (!SWIG_IsOK(res1)) {
33558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33559 }
33560 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33561 ecode2 = SWIG_AsVal_int(obj1, &val2);
33562 if (!SWIG_IsOK(ecode2)) {
33563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33564 }
33565 arg2 = static_cast< int >(val2);
33566 ecode3 = SWIG_AsVal_int(obj2, &val3);
33567 if (!SWIG_IsOK(ecode3)) {
33568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33569 }
33570 arg3 = static_cast< int >(val3);
33571 ecode4 = SWIG_AsVal_int(obj3, &val4);
33572 if (!SWIG_IsOK(ecode4)) {
33573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33574 }
33575 arg4 = static_cast< wxDragResult >(val4);
33576 {
33577 PyThreadState* __tstate = wxPyBeginAllowThreads();
33578 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33579 wxPyEndAllowThreads(__tstate);
33580 if (PyErr_Occurred()) SWIG_fail;
33581 }
33582 resultobj = SWIG_From_int(static_cast< int >(result));
33583 return resultobj;
33584 fail:
33585 return NULL;
33586 }
33587
33588
33589 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33590 PyObject *resultobj = 0;
33591 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33592 void *argp1 = 0 ;
33593 int res1 = 0 ;
33594 PyObject *swig_obj[1] ;
33595
33596 if (!args) SWIG_fail;
33597 swig_obj[0] = args;
33598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33599 if (!SWIG_IsOK(res1)) {
33600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33601 }
33602 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33603 {
33604 PyThreadState* __tstate = wxPyBeginAllowThreads();
33605 (arg1)->OnLeave();
33606 wxPyEndAllowThreads(__tstate);
33607 if (PyErr_Occurred()) SWIG_fail;
33608 }
33609 resultobj = SWIG_Py_Void();
33610 return resultobj;
33611 fail:
33612 return NULL;
33613 }
33614
33615
33616 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33617 PyObject *resultobj = 0;
33618 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33619 int arg2 ;
33620 int arg3 ;
33621 bool result;
33622 void *argp1 = 0 ;
33623 int res1 = 0 ;
33624 int val2 ;
33625 int ecode2 = 0 ;
33626 int val3 ;
33627 int ecode3 = 0 ;
33628 PyObject * obj0 = 0 ;
33629 PyObject * obj1 = 0 ;
33630 PyObject * obj2 = 0 ;
33631 char * kwnames[] = {
33632 (char *) "self",(char *) "x",(char *) "y", NULL
33633 };
33634
33635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33637 if (!SWIG_IsOK(res1)) {
33638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33639 }
33640 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33641 ecode2 = SWIG_AsVal_int(obj1, &val2);
33642 if (!SWIG_IsOK(ecode2)) {
33643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33644 }
33645 arg2 = static_cast< int >(val2);
33646 ecode3 = SWIG_AsVal_int(obj2, &val3);
33647 if (!SWIG_IsOK(ecode3)) {
33648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33649 }
33650 arg3 = static_cast< int >(val3);
33651 {
33652 PyThreadState* __tstate = wxPyBeginAllowThreads();
33653 result = (bool)(arg1)->OnDrop(arg2,arg3);
33654 wxPyEndAllowThreads(__tstate);
33655 if (PyErr_Occurred()) SWIG_fail;
33656 }
33657 {
33658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33659 }
33660 return resultobj;
33661 fail:
33662 return NULL;
33663 }
33664
33665
33666 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33667 PyObject *resultobj = 0;
33668 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33669 int arg2 ;
33670 int arg3 ;
33671 wxDragResult arg4 ;
33672 wxDragResult result;
33673 void *argp1 = 0 ;
33674 int res1 = 0 ;
33675 int val2 ;
33676 int ecode2 = 0 ;
33677 int val3 ;
33678 int ecode3 = 0 ;
33679 int val4 ;
33680 int ecode4 = 0 ;
33681 PyObject * obj0 = 0 ;
33682 PyObject * obj1 = 0 ;
33683 PyObject * obj2 = 0 ;
33684 PyObject * obj3 = 0 ;
33685 char * kwnames[] = {
33686 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33687 };
33688
33689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33691 if (!SWIG_IsOK(res1)) {
33692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33693 }
33694 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33695 ecode2 = SWIG_AsVal_int(obj1, &val2);
33696 if (!SWIG_IsOK(ecode2)) {
33697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33698 }
33699 arg2 = static_cast< int >(val2);
33700 ecode3 = SWIG_AsVal_int(obj2, &val3);
33701 if (!SWIG_IsOK(ecode3)) {
33702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33703 }
33704 arg3 = static_cast< int >(val3);
33705 ecode4 = SWIG_AsVal_int(obj3, &val4);
33706 if (!SWIG_IsOK(ecode4)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33708 }
33709 arg4 = static_cast< wxDragResult >(val4);
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 resultobj = SWIG_From_int(static_cast< int >(result));
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33724 PyObject *obj;
33725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33726 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33727 return SWIG_Py_Void();
33728 }
33729
33730 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33731 return SWIG_Python_InitShadowInstance(args);
33732 }
33733
33734 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33735 PyObject *resultobj = 0;
33736 wxPyFileDropTarget *result = 0 ;
33737
33738 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33739 {
33740 PyThreadState* __tstate = wxPyBeginAllowThreads();
33741 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33742 wxPyEndAllowThreads(__tstate);
33743 if (PyErr_Occurred()) SWIG_fail;
33744 }
33745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33746 return resultobj;
33747 fail:
33748 return NULL;
33749 }
33750
33751
33752 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33753 PyObject *resultobj = 0;
33754 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33755 PyObject *arg2 = (PyObject *) 0 ;
33756 PyObject *arg3 = (PyObject *) 0 ;
33757 void *argp1 = 0 ;
33758 int res1 = 0 ;
33759 PyObject * obj0 = 0 ;
33760 PyObject * obj1 = 0 ;
33761 PyObject * obj2 = 0 ;
33762 char * kwnames[] = {
33763 (char *) "self",(char *) "self",(char *) "_class", NULL
33764 };
33765
33766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33768 if (!SWIG_IsOK(res1)) {
33769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33770 }
33771 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33772 arg2 = obj1;
33773 arg3 = obj2;
33774 {
33775 PyThreadState* __tstate = wxPyBeginAllowThreads();
33776 (arg1)->_setCallbackInfo(arg2,arg3);
33777 wxPyEndAllowThreads(__tstate);
33778 if (PyErr_Occurred()) SWIG_fail;
33779 }
33780 resultobj = SWIG_Py_Void();
33781 return resultobj;
33782 fail:
33783 return NULL;
33784 }
33785
33786
33787 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33788 PyObject *resultobj = 0;
33789 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33790 int arg2 ;
33791 int arg3 ;
33792 wxArrayString *arg4 = 0 ;
33793 bool result;
33794 void *argp1 = 0 ;
33795 int res1 = 0 ;
33796 int val2 ;
33797 int ecode2 = 0 ;
33798 int val3 ;
33799 int ecode3 = 0 ;
33800 bool temp4 = false ;
33801 PyObject * obj0 = 0 ;
33802 PyObject * obj1 = 0 ;
33803 PyObject * obj2 = 0 ;
33804 PyObject * obj3 = 0 ;
33805 char * kwnames[] = {
33806 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33807 };
33808
33809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33811 if (!SWIG_IsOK(res1)) {
33812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33813 }
33814 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33815 ecode2 = SWIG_AsVal_int(obj1, &val2);
33816 if (!SWIG_IsOK(ecode2)) {
33817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33818 }
33819 arg2 = static_cast< int >(val2);
33820 ecode3 = SWIG_AsVal_int(obj2, &val3);
33821 if (!SWIG_IsOK(ecode3)) {
33822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33823 }
33824 arg3 = static_cast< int >(val3);
33825 {
33826 if (! PySequence_Check(obj3)) {
33827 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33828 SWIG_fail;
33829 }
33830 arg4 = new wxArrayString;
33831 temp4 = true;
33832 int i, len=PySequence_Length(obj3);
33833 for (i=0; i<len; i++) {
33834 PyObject* item = PySequence_GetItem(obj3, i);
33835 wxString* s = wxString_in_helper(item);
33836 if (PyErr_Occurred()) SWIG_fail;
33837 arg4->Add(*s);
33838 delete s;
33839 Py_DECREF(item);
33840 }
33841 }
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33845 wxPyEndAllowThreads(__tstate);
33846 if (PyErr_Occurred()) SWIG_fail;
33847 }
33848 {
33849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33850 }
33851 {
33852 if (temp4) delete arg4;
33853 }
33854 return resultobj;
33855 fail:
33856 {
33857 if (temp4) delete arg4;
33858 }
33859 return NULL;
33860 }
33861
33862
33863 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33864 PyObject *resultobj = 0;
33865 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33866 int arg2 ;
33867 int arg3 ;
33868 wxDragResult arg4 ;
33869 wxDragResult result;
33870 void *argp1 = 0 ;
33871 int res1 = 0 ;
33872 int val2 ;
33873 int ecode2 = 0 ;
33874 int val3 ;
33875 int ecode3 = 0 ;
33876 int val4 ;
33877 int ecode4 = 0 ;
33878 PyObject * obj0 = 0 ;
33879 PyObject * obj1 = 0 ;
33880 PyObject * obj2 = 0 ;
33881 PyObject * obj3 = 0 ;
33882 char * kwnames[] = {
33883 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33884 };
33885
33886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33888 if (!SWIG_IsOK(res1)) {
33889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33890 }
33891 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33892 ecode2 = SWIG_AsVal_int(obj1, &val2);
33893 if (!SWIG_IsOK(ecode2)) {
33894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33895 }
33896 arg2 = static_cast< int >(val2);
33897 ecode3 = SWIG_AsVal_int(obj2, &val3);
33898 if (!SWIG_IsOK(ecode3)) {
33899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33900 }
33901 arg3 = static_cast< int >(val3);
33902 ecode4 = SWIG_AsVal_int(obj3, &val4);
33903 if (!SWIG_IsOK(ecode4)) {
33904 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33905 }
33906 arg4 = static_cast< wxDragResult >(val4);
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 resultobj = SWIG_From_int(static_cast< int >(result));
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj = 0;
33922 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33923 int arg2 ;
33924 int arg3 ;
33925 wxDragResult arg4 ;
33926 wxDragResult result;
33927 void *argp1 = 0 ;
33928 int res1 = 0 ;
33929 int val2 ;
33930 int ecode2 = 0 ;
33931 int val3 ;
33932 int ecode3 = 0 ;
33933 int val4 ;
33934 int ecode4 = 0 ;
33935 PyObject * obj0 = 0 ;
33936 PyObject * obj1 = 0 ;
33937 PyObject * obj2 = 0 ;
33938 PyObject * obj3 = 0 ;
33939 char * kwnames[] = {
33940 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33941 };
33942
33943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33945 if (!SWIG_IsOK(res1)) {
33946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33947 }
33948 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33949 ecode2 = SWIG_AsVal_int(obj1, &val2);
33950 if (!SWIG_IsOK(ecode2)) {
33951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33952 }
33953 arg2 = static_cast< int >(val2);
33954 ecode3 = SWIG_AsVal_int(obj2, &val3);
33955 if (!SWIG_IsOK(ecode3)) {
33956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33957 }
33958 arg3 = static_cast< int >(val3);
33959 ecode4 = SWIG_AsVal_int(obj3, &val4);
33960 if (!SWIG_IsOK(ecode4)) {
33961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33962 }
33963 arg4 = static_cast< wxDragResult >(val4);
33964 {
33965 PyThreadState* __tstate = wxPyBeginAllowThreads();
33966 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33967 wxPyEndAllowThreads(__tstate);
33968 if (PyErr_Occurred()) SWIG_fail;
33969 }
33970 resultobj = SWIG_From_int(static_cast< int >(result));
33971 return resultobj;
33972 fail:
33973 return NULL;
33974 }
33975
33976
33977 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33978 PyObject *resultobj = 0;
33979 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33980 void *argp1 = 0 ;
33981 int res1 = 0 ;
33982 PyObject *swig_obj[1] ;
33983
33984 if (!args) SWIG_fail;
33985 swig_obj[0] = args;
33986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33987 if (!SWIG_IsOK(res1)) {
33988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33989 }
33990 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 (arg1)->OnLeave();
33994 wxPyEndAllowThreads(__tstate);
33995 if (PyErr_Occurred()) SWIG_fail;
33996 }
33997 resultobj = SWIG_Py_Void();
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj = 0;
34006 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34007 int arg2 ;
34008 int arg3 ;
34009 bool result;
34010 void *argp1 = 0 ;
34011 int res1 = 0 ;
34012 int val2 ;
34013 int ecode2 = 0 ;
34014 int val3 ;
34015 int ecode3 = 0 ;
34016 PyObject * obj0 = 0 ;
34017 PyObject * obj1 = 0 ;
34018 PyObject * obj2 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "self",(char *) "x",(char *) "y", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34027 }
34028 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34029 ecode2 = SWIG_AsVal_int(obj1, &val2);
34030 if (!SWIG_IsOK(ecode2)) {
34031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34032 }
34033 arg2 = static_cast< int >(val2);
34034 ecode3 = SWIG_AsVal_int(obj2, &val3);
34035 if (!SWIG_IsOK(ecode3)) {
34036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34037 }
34038 arg3 = static_cast< int >(val3);
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 result = (bool)(arg1)->OnDrop(arg2,arg3);
34042 wxPyEndAllowThreads(__tstate);
34043 if (PyErr_Occurred()) SWIG_fail;
34044 }
34045 {
34046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34047 }
34048 return resultobj;
34049 fail:
34050 return NULL;
34051 }
34052
34053
34054 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34055 PyObject *resultobj = 0;
34056 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34057 int arg2 ;
34058 int arg3 ;
34059 wxDragResult arg4 ;
34060 wxDragResult result;
34061 void *argp1 = 0 ;
34062 int res1 = 0 ;
34063 int val2 ;
34064 int ecode2 = 0 ;
34065 int val3 ;
34066 int ecode3 = 0 ;
34067 int val4 ;
34068 int ecode4 = 0 ;
34069 PyObject * obj0 = 0 ;
34070 PyObject * obj1 = 0 ;
34071 PyObject * obj2 = 0 ;
34072 PyObject * obj3 = 0 ;
34073 char * kwnames[] = {
34074 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34075 };
34076
34077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34079 if (!SWIG_IsOK(res1)) {
34080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34081 }
34082 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34083 ecode2 = SWIG_AsVal_int(obj1, &val2);
34084 if (!SWIG_IsOK(ecode2)) {
34085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34086 }
34087 arg2 = static_cast< int >(val2);
34088 ecode3 = SWIG_AsVal_int(obj2, &val3);
34089 if (!SWIG_IsOK(ecode3)) {
34090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34091 }
34092 arg3 = static_cast< int >(val3);
34093 ecode4 = SWIG_AsVal_int(obj3, &val4);
34094 if (!SWIG_IsOK(ecode4)) {
34095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34096 }
34097 arg4 = static_cast< wxDragResult >(val4);
34098 {
34099 PyThreadState* __tstate = wxPyBeginAllowThreads();
34100 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34101 wxPyEndAllowThreads(__tstate);
34102 if (PyErr_Occurred()) SWIG_fail;
34103 }
34104 resultobj = SWIG_From_int(static_cast< int >(result));
34105 return resultobj;
34106 fail:
34107 return NULL;
34108 }
34109
34110
34111 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34112 PyObject *obj;
34113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34114 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
34115 return SWIG_Py_Void();
34116 }
34117
34118 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34119 return SWIG_Python_InitShadowInstance(args);
34120 }
34121
34122 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34123 PyObject *resultobj = 0;
34124 wxClipboard *result = 0 ;
34125
34126 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34127 {
34128 PyThreadState* __tstate = wxPyBeginAllowThreads();
34129 result = (wxClipboard *)new wxClipboard();
34130 wxPyEndAllowThreads(__tstate);
34131 if (PyErr_Occurred()) SWIG_fail;
34132 }
34133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34134 return resultobj;
34135 fail:
34136 return NULL;
34137 }
34138
34139
34140 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34141 PyObject *resultobj = 0;
34142 wxClipboard *arg1 = (wxClipboard *) 0 ;
34143 void *argp1 = 0 ;
34144 int res1 = 0 ;
34145 PyObject *swig_obj[1] ;
34146
34147 if (!args) SWIG_fail;
34148 swig_obj[0] = args;
34149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34150 if (!SWIG_IsOK(res1)) {
34151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34152 }
34153 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34154 {
34155 PyThreadState* __tstate = wxPyBeginAllowThreads();
34156 delete arg1;
34157
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 resultobj = SWIG_Py_Void();
34162 return resultobj;
34163 fail:
34164 return NULL;
34165 }
34166
34167
34168 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34169 PyObject *resultobj = 0;
34170 wxClipboard *arg1 = (wxClipboard *) 0 ;
34171 bool result;
34172 void *argp1 = 0 ;
34173 int res1 = 0 ;
34174 PyObject *swig_obj[1] ;
34175
34176 if (!args) SWIG_fail;
34177 swig_obj[0] = args;
34178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34179 if (!SWIG_IsOK(res1)) {
34180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34181 }
34182 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34183 {
34184 PyThreadState* __tstate = wxPyBeginAllowThreads();
34185 result = (bool)(arg1)->Open();
34186 wxPyEndAllowThreads(__tstate);
34187 if (PyErr_Occurred()) SWIG_fail;
34188 }
34189 {
34190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34191 }
34192 return resultobj;
34193 fail:
34194 return NULL;
34195 }
34196
34197
34198 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34199 PyObject *resultobj = 0;
34200 wxClipboard *arg1 = (wxClipboard *) 0 ;
34201 void *argp1 = 0 ;
34202 int res1 = 0 ;
34203 PyObject *swig_obj[1] ;
34204
34205 if (!args) SWIG_fail;
34206 swig_obj[0] = args;
34207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34210 }
34211 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 (arg1)->Close();
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 resultobj = SWIG_Py_Void();
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34226 PyObject *resultobj = 0;
34227 wxClipboard *arg1 = (wxClipboard *) 0 ;
34228 bool result;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 PyObject *swig_obj[1] ;
34232
34233 if (!args) SWIG_fail;
34234 swig_obj[0] = args;
34235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34238 }
34239 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 {
34247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34248 }
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34256 PyObject *resultobj = 0;
34257 wxClipboard *arg1 = (wxClipboard *) 0 ;
34258 wxDataObject *arg2 = (wxDataObject *) 0 ;
34259 bool result;
34260 void *argp1 = 0 ;
34261 int res1 = 0 ;
34262 int res2 = 0 ;
34263 PyObject * obj0 = 0 ;
34264 PyObject * obj1 = 0 ;
34265 char * kwnames[] = {
34266 (char *) "self",(char *) "data", NULL
34267 };
34268
34269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34271 if (!SWIG_IsOK(res1)) {
34272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34273 }
34274 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34275 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34276 if (!SWIG_IsOK(res2)) {
34277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34278 }
34279 {
34280 PyThreadState* __tstate = wxPyBeginAllowThreads();
34281 result = (bool)(arg1)->AddData(arg2);
34282 wxPyEndAllowThreads(__tstate);
34283 if (PyErr_Occurred()) SWIG_fail;
34284 }
34285 {
34286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34287 }
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj = 0;
34296 wxClipboard *arg1 = (wxClipboard *) 0 ;
34297 wxDataObject *arg2 = (wxDataObject *) 0 ;
34298 bool result;
34299 void *argp1 = 0 ;
34300 int res1 = 0 ;
34301 int res2 = 0 ;
34302 PyObject * obj0 = 0 ;
34303 PyObject * obj1 = 0 ;
34304 char * kwnames[] = {
34305 (char *) "self",(char *) "data", NULL
34306 };
34307
34308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34310 if (!SWIG_IsOK(res1)) {
34311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34312 }
34313 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34314 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34315 if (!SWIG_IsOK(res2)) {
34316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34317 }
34318 {
34319 PyThreadState* __tstate = wxPyBeginAllowThreads();
34320 result = (bool)(arg1)->SetData(arg2);
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 {
34325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34326 }
34327 return resultobj;
34328 fail:
34329 return NULL;
34330 }
34331
34332
34333 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34334 PyObject *resultobj = 0;
34335 wxClipboard *arg1 = (wxClipboard *) 0 ;
34336 wxDataFormat *arg2 = 0 ;
34337 bool result;
34338 void *argp1 = 0 ;
34339 int res1 = 0 ;
34340 void *argp2 = 0 ;
34341 int res2 = 0 ;
34342 PyObject * obj0 = 0 ;
34343 PyObject * obj1 = 0 ;
34344 char * kwnames[] = {
34345 (char *) "self",(char *) "format", NULL
34346 };
34347
34348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34350 if (!SWIG_IsOK(res1)) {
34351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34352 }
34353 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34354 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34355 if (!SWIG_IsOK(res2)) {
34356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34357 }
34358 if (!argp2) {
34359 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34360 }
34361 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34362 {
34363 PyThreadState* __tstate = wxPyBeginAllowThreads();
34364 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34365 wxPyEndAllowThreads(__tstate);
34366 if (PyErr_Occurred()) SWIG_fail;
34367 }
34368 {
34369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34370 }
34371 return resultobj;
34372 fail:
34373 return NULL;
34374 }
34375
34376
34377 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34378 PyObject *resultobj = 0;
34379 wxClipboard *arg1 = (wxClipboard *) 0 ;
34380 wxDataObject *arg2 = 0 ;
34381 bool result;
34382 void *argp1 = 0 ;
34383 int res1 = 0 ;
34384 void *argp2 = 0 ;
34385 int res2 = 0 ;
34386 PyObject * obj0 = 0 ;
34387 PyObject * obj1 = 0 ;
34388 char * kwnames[] = {
34389 (char *) "self",(char *) "data", NULL
34390 };
34391
34392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34394 if (!SWIG_IsOK(res1)) {
34395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34396 }
34397 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34398 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34399 if (!SWIG_IsOK(res2)) {
34400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34401 }
34402 if (!argp2) {
34403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34404 }
34405 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34406 {
34407 PyThreadState* __tstate = wxPyBeginAllowThreads();
34408 result = (bool)(arg1)->GetData(*arg2);
34409 wxPyEndAllowThreads(__tstate);
34410 if (PyErr_Occurred()) SWIG_fail;
34411 }
34412 {
34413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34414 }
34415 return resultobj;
34416 fail:
34417 return NULL;
34418 }
34419
34420
34421 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34422 PyObject *resultobj = 0;
34423 wxClipboard *arg1 = (wxClipboard *) 0 ;
34424 void *argp1 = 0 ;
34425 int res1 = 0 ;
34426 PyObject *swig_obj[1] ;
34427
34428 if (!args) SWIG_fail;
34429 swig_obj[0] = args;
34430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34431 if (!SWIG_IsOK(res1)) {
34432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34433 }
34434 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34435 {
34436 PyThreadState* __tstate = wxPyBeginAllowThreads();
34437 (arg1)->Clear();
34438 wxPyEndAllowThreads(__tstate);
34439 if (PyErr_Occurred()) SWIG_fail;
34440 }
34441 resultobj = SWIG_Py_Void();
34442 return resultobj;
34443 fail:
34444 return NULL;
34445 }
34446
34447
34448 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34449 PyObject *resultobj = 0;
34450 wxClipboard *arg1 = (wxClipboard *) 0 ;
34451 bool result;
34452 void *argp1 = 0 ;
34453 int res1 = 0 ;
34454 PyObject *swig_obj[1] ;
34455
34456 if (!args) SWIG_fail;
34457 swig_obj[0] = args;
34458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34459 if (!SWIG_IsOK(res1)) {
34460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34461 }
34462 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34463 {
34464 PyThreadState* __tstate = wxPyBeginAllowThreads();
34465 result = (bool)(arg1)->Flush();
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 {
34470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34471 }
34472 return resultobj;
34473 fail:
34474 return NULL;
34475 }
34476
34477
34478 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34479 PyObject *resultobj = 0;
34480 wxClipboard *arg1 = (wxClipboard *) 0 ;
34481 bool arg2 = (bool) true ;
34482 void *argp1 = 0 ;
34483 int res1 = 0 ;
34484 bool val2 ;
34485 int ecode2 = 0 ;
34486 PyObject * obj0 = 0 ;
34487 PyObject * obj1 = 0 ;
34488 char * kwnames[] = {
34489 (char *) "self",(char *) "primary", NULL
34490 };
34491
34492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34494 if (!SWIG_IsOK(res1)) {
34495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34496 }
34497 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34498 if (obj1) {
34499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34500 if (!SWIG_IsOK(ecode2)) {
34501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34502 }
34503 arg2 = static_cast< bool >(val2);
34504 }
34505 {
34506 PyThreadState* __tstate = wxPyBeginAllowThreads();
34507 (arg1)->UsePrimarySelection(arg2);
34508 wxPyEndAllowThreads(__tstate);
34509 if (PyErr_Occurred()) SWIG_fail;
34510 }
34511 resultobj = SWIG_Py_Void();
34512 return resultobj;
34513 fail:
34514 return NULL;
34515 }
34516
34517
34518 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34519 PyObject *resultobj = 0;
34520 wxClipboard *result = 0 ;
34521
34522 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34523 {
34524 PyThreadState* __tstate = wxPyBeginAllowThreads();
34525 result = (wxClipboard *)wxClipboard::Get();
34526 wxPyEndAllowThreads(__tstate);
34527 if (PyErr_Occurred()) SWIG_fail;
34528 }
34529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34530 return resultobj;
34531 fail:
34532 return NULL;
34533 }
34534
34535
34536 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34537 PyObject *obj;
34538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34539 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34540 return SWIG_Py_Void();
34541 }
34542
34543 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34544 return SWIG_Python_InitShadowInstance(args);
34545 }
34546
34547 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34548 PyObject *resultobj = 0;
34549 wxClipboard *arg1 = (wxClipboard *) NULL ;
34550 wxClipboardLocker *result = 0 ;
34551 void *argp1 = 0 ;
34552 int res1 = 0 ;
34553 PyObject * obj0 = 0 ;
34554 char * kwnames[] = {
34555 (char *) "clipboard", NULL
34556 };
34557
34558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34559 if (obj0) {
34560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34561 if (!SWIG_IsOK(res1)) {
34562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34563 }
34564 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34565 }
34566 {
34567 PyThreadState* __tstate = wxPyBeginAllowThreads();
34568 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34569 wxPyEndAllowThreads(__tstate);
34570 if (PyErr_Occurred()) SWIG_fail;
34571 }
34572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34573 return resultobj;
34574 fail:
34575 return NULL;
34576 }
34577
34578
34579 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34580 PyObject *resultobj = 0;
34581 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34582 void *argp1 = 0 ;
34583 int res1 = 0 ;
34584 PyObject *swig_obj[1] ;
34585
34586 if (!args) SWIG_fail;
34587 swig_obj[0] = args;
34588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34589 if (!SWIG_IsOK(res1)) {
34590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34591 }
34592 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34593 {
34594 PyThreadState* __tstate = wxPyBeginAllowThreads();
34595 delete arg1;
34596
34597 wxPyEndAllowThreads(__tstate);
34598 if (PyErr_Occurred()) SWIG_fail;
34599 }
34600 resultobj = SWIG_Py_Void();
34601 return resultobj;
34602 fail:
34603 return NULL;
34604 }
34605
34606
34607 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34608 PyObject *resultobj = 0;
34609 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34610 bool result;
34611 void *argp1 = 0 ;
34612 int res1 = 0 ;
34613 PyObject *swig_obj[1] ;
34614
34615 if (!args) SWIG_fail;
34616 swig_obj[0] = args;
34617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34618 if (!SWIG_IsOK(res1)) {
34619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34620 }
34621 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 result = (bool)wxClipboardLocker___nonzero__(arg1);
34625 wxPyEndAllowThreads(__tstate);
34626 if (PyErr_Occurred()) SWIG_fail;
34627 }
34628 {
34629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34630 }
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34638 PyObject *obj;
34639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34640 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34641 return SWIG_Py_Void();
34642 }
34643
34644 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34645 return SWIG_Python_InitShadowInstance(args);
34646 }
34647
34648 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34649 PyObject *resultobj = 0;
34650 int arg1 = (int) 0 ;
34651 int arg2 = (int) 0 ;
34652 int arg3 = (int) 0 ;
34653 int arg4 = (int) 0 ;
34654 wxVideoMode *result = 0 ;
34655 int val1 ;
34656 int ecode1 = 0 ;
34657 int val2 ;
34658 int ecode2 = 0 ;
34659 int val3 ;
34660 int ecode3 = 0 ;
34661 int val4 ;
34662 int ecode4 = 0 ;
34663 PyObject * obj0 = 0 ;
34664 PyObject * obj1 = 0 ;
34665 PyObject * obj2 = 0 ;
34666 PyObject * obj3 = 0 ;
34667 char * kwnames[] = {
34668 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34669 };
34670
34671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34672 if (obj0) {
34673 ecode1 = SWIG_AsVal_int(obj0, &val1);
34674 if (!SWIG_IsOK(ecode1)) {
34675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34676 }
34677 arg1 = static_cast< int >(val1);
34678 }
34679 if (obj1) {
34680 ecode2 = SWIG_AsVal_int(obj1, &val2);
34681 if (!SWIG_IsOK(ecode2)) {
34682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34683 }
34684 arg2 = static_cast< int >(val2);
34685 }
34686 if (obj2) {
34687 ecode3 = SWIG_AsVal_int(obj2, &val3);
34688 if (!SWIG_IsOK(ecode3)) {
34689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34690 }
34691 arg3 = static_cast< int >(val3);
34692 }
34693 if (obj3) {
34694 ecode4 = SWIG_AsVal_int(obj3, &val4);
34695 if (!SWIG_IsOK(ecode4)) {
34696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34697 }
34698 arg4 = static_cast< int >(val4);
34699 }
34700 {
34701 PyThreadState* __tstate = wxPyBeginAllowThreads();
34702 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34703 wxPyEndAllowThreads(__tstate);
34704 if (PyErr_Occurred()) SWIG_fail;
34705 }
34706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34707 return resultobj;
34708 fail:
34709 return NULL;
34710 }
34711
34712
34713 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34714 PyObject *resultobj = 0;
34715 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34716 void *argp1 = 0 ;
34717 int res1 = 0 ;
34718 PyObject *swig_obj[1] ;
34719
34720 if (!args) SWIG_fail;
34721 swig_obj[0] = args;
34722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34723 if (!SWIG_IsOK(res1)) {
34724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34725 }
34726 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34727 {
34728 PyThreadState* __tstate = wxPyBeginAllowThreads();
34729 delete arg1;
34730
34731 wxPyEndAllowThreads(__tstate);
34732 if (PyErr_Occurred()) SWIG_fail;
34733 }
34734 resultobj = SWIG_Py_Void();
34735 return resultobj;
34736 fail:
34737 return NULL;
34738 }
34739
34740
34741 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34742 PyObject *resultobj = 0;
34743 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34744 wxVideoMode *arg2 = 0 ;
34745 bool result;
34746 void *argp1 = 0 ;
34747 int res1 = 0 ;
34748 void *argp2 = 0 ;
34749 int res2 = 0 ;
34750 PyObject * obj0 = 0 ;
34751 PyObject * obj1 = 0 ;
34752 char * kwnames[] = {
34753 (char *) "self",(char *) "other", NULL
34754 };
34755
34756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34758 if (!SWIG_IsOK(res1)) {
34759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34760 }
34761 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34763 if (!SWIG_IsOK(res2)) {
34764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34765 }
34766 if (!argp2) {
34767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34768 }
34769 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34770 {
34771 PyThreadState* __tstate = wxPyBeginAllowThreads();
34772 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34773 wxPyEndAllowThreads(__tstate);
34774 if (PyErr_Occurred()) SWIG_fail;
34775 }
34776 {
34777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34778 }
34779 return resultobj;
34780 fail:
34781 return NULL;
34782 }
34783
34784
34785 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34786 PyObject *resultobj = 0;
34787 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34788 int result;
34789 void *argp1 = 0 ;
34790 int res1 = 0 ;
34791 PyObject *swig_obj[1] ;
34792
34793 if (!args) SWIG_fail;
34794 swig_obj[0] = args;
34795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34796 if (!SWIG_IsOK(res1)) {
34797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34798 }
34799 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34800 {
34801 PyThreadState* __tstate = wxPyBeginAllowThreads();
34802 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34803 wxPyEndAllowThreads(__tstate);
34804 if (PyErr_Occurred()) SWIG_fail;
34805 }
34806 resultobj = SWIG_From_int(static_cast< int >(result));
34807 return resultobj;
34808 fail:
34809 return NULL;
34810 }
34811
34812
34813 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34814 PyObject *resultobj = 0;
34815 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34816 int result;
34817 void *argp1 = 0 ;
34818 int res1 = 0 ;
34819 PyObject *swig_obj[1] ;
34820
34821 if (!args) SWIG_fail;
34822 swig_obj[0] = args;
34823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34824 if (!SWIG_IsOK(res1)) {
34825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34826 }
34827 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34828 {
34829 PyThreadState* __tstate = wxPyBeginAllowThreads();
34830 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34831 wxPyEndAllowThreads(__tstate);
34832 if (PyErr_Occurred()) SWIG_fail;
34833 }
34834 resultobj = SWIG_From_int(static_cast< int >(result));
34835 return resultobj;
34836 fail:
34837 return NULL;
34838 }
34839
34840
34841 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34842 PyObject *resultobj = 0;
34843 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34844 int result;
34845 void *argp1 = 0 ;
34846 int res1 = 0 ;
34847 PyObject *swig_obj[1] ;
34848
34849 if (!args) SWIG_fail;
34850 swig_obj[0] = args;
34851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34852 if (!SWIG_IsOK(res1)) {
34853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34854 }
34855 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34856 {
34857 PyThreadState* __tstate = wxPyBeginAllowThreads();
34858 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34859 wxPyEndAllowThreads(__tstate);
34860 if (PyErr_Occurred()) SWIG_fail;
34861 }
34862 resultobj = SWIG_From_int(static_cast< int >(result));
34863 return resultobj;
34864 fail:
34865 return NULL;
34866 }
34867
34868
34869 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34870 PyObject *resultobj = 0;
34871 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34872 bool result;
34873 void *argp1 = 0 ;
34874 int res1 = 0 ;
34875 PyObject *swig_obj[1] ;
34876
34877 if (!args) SWIG_fail;
34878 swig_obj[0] = args;
34879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34880 if (!SWIG_IsOK(res1)) {
34881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34882 }
34883 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34884 {
34885 PyThreadState* __tstate = wxPyBeginAllowThreads();
34886 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34887 wxPyEndAllowThreads(__tstate);
34888 if (PyErr_Occurred()) SWIG_fail;
34889 }
34890 {
34891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34892 }
34893 return resultobj;
34894 fail:
34895 return NULL;
34896 }
34897
34898
34899 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34900 PyObject *resultobj = 0;
34901 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34902 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34903 bool result;
34904 void *argp1 = 0 ;
34905 int res1 = 0 ;
34906 void *argp2 = 0 ;
34907 int res2 = 0 ;
34908 PyObject * obj0 = 0 ;
34909 PyObject * obj1 = 0 ;
34910 char * kwnames[] = {
34911 (char *) "self",(char *) "other", NULL
34912 };
34913
34914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34916 if (!SWIG_IsOK(res1)) {
34917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34918 }
34919 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34921 if (!SWIG_IsOK(res2)) {
34922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34923 }
34924 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 {
34932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34933 }
34934 return resultobj;
34935 fail:
34936 return NULL;
34937 }
34938
34939
34940 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34941 PyObject *resultobj = 0;
34942 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34943 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34944 bool result;
34945 void *argp1 = 0 ;
34946 int res1 = 0 ;
34947 void *argp2 = 0 ;
34948 int res2 = 0 ;
34949 PyObject * obj0 = 0 ;
34950 PyObject * obj1 = 0 ;
34951 char * kwnames[] = {
34952 (char *) "self",(char *) "other", NULL
34953 };
34954
34955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34957 if (!SWIG_IsOK(res1)) {
34958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34959 }
34960 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34961 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34962 if (!SWIG_IsOK(res2)) {
34963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34964 }
34965 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34966 {
34967 PyThreadState* __tstate = wxPyBeginAllowThreads();
34968 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34969 wxPyEndAllowThreads(__tstate);
34970 if (PyErr_Occurred()) SWIG_fail;
34971 }
34972 {
34973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34974 }
34975 return resultobj;
34976 fail:
34977 return NULL;
34978 }
34979
34980
34981 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34982 PyObject *resultobj = 0;
34983 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34984 int arg2 ;
34985 void *argp1 = 0 ;
34986 int res1 = 0 ;
34987 int val2 ;
34988 int ecode2 = 0 ;
34989 PyObject *swig_obj[2] ;
34990
34991 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34993 if (!SWIG_IsOK(res1)) {
34994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34995 }
34996 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34997 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34998 if (!SWIG_IsOK(ecode2)) {
34999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35000 }
35001 arg2 = static_cast< int >(val2);
35002 if (arg1) (arg1)->w = arg2;
35003
35004 resultobj = SWIG_Py_Void();
35005 return resultobj;
35006 fail:
35007 return NULL;
35008 }
35009
35010
35011 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35012 PyObject *resultobj = 0;
35013 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35014 int result;
35015 void *argp1 = 0 ;
35016 int res1 = 0 ;
35017 PyObject *swig_obj[1] ;
35018
35019 if (!args) SWIG_fail;
35020 swig_obj[0] = args;
35021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35022 if (!SWIG_IsOK(res1)) {
35023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35024 }
35025 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35026 result = (int) ((arg1)->w);
35027 resultobj = SWIG_From_int(static_cast< int >(result));
35028 return resultobj;
35029 fail:
35030 return NULL;
35031 }
35032
35033
35034 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35035 PyObject *resultobj = 0;
35036 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35037 int arg2 ;
35038 void *argp1 = 0 ;
35039 int res1 = 0 ;
35040 int val2 ;
35041 int ecode2 = 0 ;
35042 PyObject *swig_obj[2] ;
35043
35044 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
35045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35046 if (!SWIG_IsOK(res1)) {
35047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35048 }
35049 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35050 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35051 if (!SWIG_IsOK(ecode2)) {
35052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
35053 }
35054 arg2 = static_cast< int >(val2);
35055 if (arg1) (arg1)->h = arg2;
35056
35057 resultobj = SWIG_Py_Void();
35058 return resultobj;
35059 fail:
35060 return NULL;
35061 }
35062
35063
35064 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35065 PyObject *resultobj = 0;
35066 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35067 int result;
35068 void *argp1 = 0 ;
35069 int res1 = 0 ;
35070 PyObject *swig_obj[1] ;
35071
35072 if (!args) SWIG_fail;
35073 swig_obj[0] = args;
35074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35075 if (!SWIG_IsOK(res1)) {
35076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35077 }
35078 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35079 result = (int) ((arg1)->h);
35080 resultobj = SWIG_From_int(static_cast< int >(result));
35081 return resultobj;
35082 fail:
35083 return NULL;
35084 }
35085
35086
35087 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35088 PyObject *resultobj = 0;
35089 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35090 int arg2 ;
35091 void *argp1 = 0 ;
35092 int res1 = 0 ;
35093 int val2 ;
35094 int ecode2 = 0 ;
35095 PyObject *swig_obj[2] ;
35096
35097 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
35098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35099 if (!SWIG_IsOK(res1)) {
35100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35101 }
35102 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35103 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35104 if (!SWIG_IsOK(ecode2)) {
35105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
35106 }
35107 arg2 = static_cast< int >(val2);
35108 if (arg1) (arg1)->bpp = arg2;
35109
35110 resultobj = SWIG_Py_Void();
35111 return resultobj;
35112 fail:
35113 return NULL;
35114 }
35115
35116
35117 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35118 PyObject *resultobj = 0;
35119 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35120 int result;
35121 void *argp1 = 0 ;
35122 int res1 = 0 ;
35123 PyObject *swig_obj[1] ;
35124
35125 if (!args) SWIG_fail;
35126 swig_obj[0] = args;
35127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35128 if (!SWIG_IsOK(res1)) {
35129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35130 }
35131 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35132 result = (int) ((arg1)->bpp);
35133 resultobj = SWIG_From_int(static_cast< int >(result));
35134 return resultobj;
35135 fail:
35136 return NULL;
35137 }
35138
35139
35140 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35141 PyObject *resultobj = 0;
35142 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35143 int arg2 ;
35144 void *argp1 = 0 ;
35145 int res1 = 0 ;
35146 int val2 ;
35147 int ecode2 = 0 ;
35148 PyObject *swig_obj[2] ;
35149
35150 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35152 if (!SWIG_IsOK(res1)) {
35153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35154 }
35155 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35156 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35157 if (!SWIG_IsOK(ecode2)) {
35158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35159 }
35160 arg2 = static_cast< int >(val2);
35161 if (arg1) (arg1)->refresh = arg2;
35162
35163 resultobj = SWIG_Py_Void();
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35171 PyObject *resultobj = 0;
35172 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35173 int result;
35174 void *argp1 = 0 ;
35175 int res1 = 0 ;
35176 PyObject *swig_obj[1] ;
35177
35178 if (!args) SWIG_fail;
35179 swig_obj[0] = args;
35180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35183 }
35184 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35185 result = (int) ((arg1)->refresh);
35186 resultobj = SWIG_From_int(static_cast< int >(result));
35187 return resultobj;
35188 fail:
35189 return NULL;
35190 }
35191
35192
35193 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35194 PyObject *obj;
35195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35196 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35197 return SWIG_Py_Void();
35198 }
35199
35200 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35201 return SWIG_Python_InitShadowInstance(args);
35202 }
35203
35204 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35205 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35206 return 1;
35207 }
35208
35209
35210 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35211 PyObject *pyobj = 0;
35212
35213 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35214 return pyobj;
35215 }
35216
35217
35218 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35219 PyObject *resultobj = 0;
35220 size_t arg1 = (size_t) 0 ;
35221 wxDisplay *result = 0 ;
35222 size_t val1 ;
35223 int ecode1 = 0 ;
35224 PyObject * obj0 = 0 ;
35225 char * kwnames[] = {
35226 (char *) "index", NULL
35227 };
35228
35229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35230 if (obj0) {
35231 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35232 if (!SWIG_IsOK(ecode1)) {
35233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35234 }
35235 arg1 = static_cast< size_t >(val1);
35236 }
35237 {
35238 PyThreadState* __tstate = wxPyBeginAllowThreads();
35239 result = (wxDisplay *)new wxDisplay(arg1);
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35251 PyObject *resultobj = 0;
35252 wxDisplay *arg1 = (wxDisplay *) 0 ;
35253 void *argp1 = 0 ;
35254 int res1 = 0 ;
35255 PyObject *swig_obj[1] ;
35256
35257 if (!args) SWIG_fail;
35258 swig_obj[0] = args;
35259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35260 if (!SWIG_IsOK(res1)) {
35261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35262 }
35263 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35264 {
35265 PyThreadState* __tstate = wxPyBeginAllowThreads();
35266 delete arg1;
35267
35268 wxPyEndAllowThreads(__tstate);
35269 if (PyErr_Occurred()) SWIG_fail;
35270 }
35271 resultobj = SWIG_Py_Void();
35272 return resultobj;
35273 fail:
35274 return NULL;
35275 }
35276
35277
35278 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35279 PyObject *resultobj = 0;
35280 size_t result;
35281
35282 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 result = (size_t)wxDisplay::GetCount();
35286 wxPyEndAllowThreads(__tstate);
35287 if (PyErr_Occurred()) SWIG_fail;
35288 }
35289 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35290 return resultobj;
35291 fail:
35292 return NULL;
35293 }
35294
35295
35296 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35297 PyObject *resultobj = 0;
35298 wxPoint *arg1 = 0 ;
35299 int result;
35300 wxPoint temp1 ;
35301 PyObject * obj0 = 0 ;
35302 char * kwnames[] = {
35303 (char *) "pt", NULL
35304 };
35305
35306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35307 {
35308 arg1 = &temp1;
35309 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35310 }
35311 {
35312 PyThreadState* __tstate = wxPyBeginAllowThreads();
35313 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35314 wxPyEndAllowThreads(__tstate);
35315 if (PyErr_Occurred()) SWIG_fail;
35316 }
35317 resultobj = SWIG_From_int(static_cast< int >(result));
35318 return resultobj;
35319 fail:
35320 return NULL;
35321 }
35322
35323
35324 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35325 PyObject *resultobj = 0;
35326 wxWindow *arg1 = (wxWindow *) 0 ;
35327 int result;
35328 void *argp1 = 0 ;
35329 int res1 = 0 ;
35330 PyObject * obj0 = 0 ;
35331 char * kwnames[] = {
35332 (char *) "window", NULL
35333 };
35334
35335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35337 if (!SWIG_IsOK(res1)) {
35338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35339 }
35340 arg1 = reinterpret_cast< wxWindow * >(argp1);
35341 {
35342 PyThreadState* __tstate = wxPyBeginAllowThreads();
35343 result = (int)wxDisplay::GetFromWindow(arg1);
35344 wxPyEndAllowThreads(__tstate);
35345 if (PyErr_Occurred()) SWIG_fail;
35346 }
35347 resultobj = SWIG_From_int(static_cast< int >(result));
35348 return resultobj;
35349 fail:
35350 return NULL;
35351 }
35352
35353
35354 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35355 PyObject *resultobj = 0;
35356 wxDisplay *arg1 = (wxDisplay *) 0 ;
35357 bool result;
35358 void *argp1 = 0 ;
35359 int res1 = 0 ;
35360 PyObject *swig_obj[1] ;
35361
35362 if (!args) SWIG_fail;
35363 swig_obj[0] = args;
35364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35365 if (!SWIG_IsOK(res1)) {
35366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35367 }
35368 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35369 {
35370 PyThreadState* __tstate = wxPyBeginAllowThreads();
35371 result = (bool)((wxDisplay const *)arg1)->IsOk();
35372 wxPyEndAllowThreads(__tstate);
35373 if (PyErr_Occurred()) SWIG_fail;
35374 }
35375 {
35376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35377 }
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35385 PyObject *resultobj = 0;
35386 wxDisplay *arg1 = (wxDisplay *) 0 ;
35387 wxRect result;
35388 void *argp1 = 0 ;
35389 int res1 = 0 ;
35390 PyObject *swig_obj[1] ;
35391
35392 if (!args) SWIG_fail;
35393 swig_obj[0] = args;
35394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35395 if (!SWIG_IsOK(res1)) {
35396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35397 }
35398 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = ((wxDisplay const *)arg1)->GetGeometry();
35402 wxPyEndAllowThreads(__tstate);
35403 if (PyErr_Occurred()) SWIG_fail;
35404 }
35405 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35406 return resultobj;
35407 fail:
35408 return NULL;
35409 }
35410
35411
35412 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35413 PyObject *resultobj = 0;
35414 wxDisplay *arg1 = (wxDisplay *) 0 ;
35415 wxRect result;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 PyObject *swig_obj[1] ;
35419
35420 if (!args) SWIG_fail;
35421 swig_obj[0] = args;
35422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35423 if (!SWIG_IsOK(res1)) {
35424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35425 }
35426 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 result = ((wxDisplay const *)arg1)->GetClientArea();
35430 wxPyEndAllowThreads(__tstate);
35431 if (PyErr_Occurred()) SWIG_fail;
35432 }
35433 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35434 return resultobj;
35435 fail:
35436 return NULL;
35437 }
35438
35439
35440 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35441 PyObject *resultobj = 0;
35442 wxDisplay *arg1 = (wxDisplay *) 0 ;
35443 wxString result;
35444 void *argp1 = 0 ;
35445 int res1 = 0 ;
35446 PyObject *swig_obj[1] ;
35447
35448 if (!args) SWIG_fail;
35449 swig_obj[0] = args;
35450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35451 if (!SWIG_IsOK(res1)) {
35452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35453 }
35454 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35455 {
35456 PyThreadState* __tstate = wxPyBeginAllowThreads();
35457 result = ((wxDisplay const *)arg1)->GetName();
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 {
35462 #if wxUSE_UNICODE
35463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35464 #else
35465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35466 #endif
35467 }
35468 return resultobj;
35469 fail:
35470 return NULL;
35471 }
35472
35473
35474 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35475 PyObject *resultobj = 0;
35476 wxDisplay *arg1 = (wxDisplay *) 0 ;
35477 bool result;
35478 void *argp1 = 0 ;
35479 int res1 = 0 ;
35480 PyObject *swig_obj[1] ;
35481
35482 if (!args) SWIG_fail;
35483 swig_obj[0] = args;
35484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35485 if (!SWIG_IsOK(res1)) {
35486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35487 }
35488 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35489 {
35490 PyThreadState* __tstate = wxPyBeginAllowThreads();
35491 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35492 wxPyEndAllowThreads(__tstate);
35493 if (PyErr_Occurred()) SWIG_fail;
35494 }
35495 {
35496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35497 }
35498 return resultobj;
35499 fail:
35500 return NULL;
35501 }
35502
35503
35504 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35505 PyObject *resultobj = 0;
35506 wxDisplay *arg1 = (wxDisplay *) 0 ;
35507 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35508 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35509 PyObject *result = 0 ;
35510 void *argp1 = 0 ;
35511 int res1 = 0 ;
35512 void *argp2 = 0 ;
35513 int res2 = 0 ;
35514 PyObject * obj0 = 0 ;
35515 PyObject * obj1 = 0 ;
35516 char * kwnames[] = {
35517 (char *) "self",(char *) "mode", NULL
35518 };
35519
35520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35522 if (!SWIG_IsOK(res1)) {
35523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35524 }
35525 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35526 if (obj1) {
35527 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35528 if (!SWIG_IsOK(res2)) {
35529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35530 }
35531 if (!argp2) {
35532 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35533 }
35534 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35535 }
35536 {
35537 PyThreadState* __tstate = wxPyBeginAllowThreads();
35538 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35539 wxPyEndAllowThreads(__tstate);
35540 if (PyErr_Occurred()) SWIG_fail;
35541 }
35542 resultobj = result;
35543 return resultobj;
35544 fail:
35545 return NULL;
35546 }
35547
35548
35549 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35550 PyObject *resultobj = 0;
35551 wxDisplay *arg1 = (wxDisplay *) 0 ;
35552 wxVideoMode result;
35553 void *argp1 = 0 ;
35554 int res1 = 0 ;
35555 PyObject *swig_obj[1] ;
35556
35557 if (!args) SWIG_fail;
35558 swig_obj[0] = args;
35559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35560 if (!SWIG_IsOK(res1)) {
35561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35562 }
35563 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35564 {
35565 PyThreadState* __tstate = wxPyBeginAllowThreads();
35566 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35567 wxPyEndAllowThreads(__tstate);
35568 if (PyErr_Occurred()) SWIG_fail;
35569 }
35570 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35571 return resultobj;
35572 fail:
35573 return NULL;
35574 }
35575
35576
35577 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35578 PyObject *resultobj = 0;
35579 wxDisplay *arg1 = (wxDisplay *) 0 ;
35580 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35581 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35582 bool result;
35583 void *argp1 = 0 ;
35584 int res1 = 0 ;
35585 void *argp2 = 0 ;
35586 int res2 = 0 ;
35587 PyObject * obj0 = 0 ;
35588 PyObject * obj1 = 0 ;
35589 char * kwnames[] = {
35590 (char *) "self",(char *) "mode", NULL
35591 };
35592
35593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35595 if (!SWIG_IsOK(res1)) {
35596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35597 }
35598 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35599 if (obj1) {
35600 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35601 if (!SWIG_IsOK(res2)) {
35602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35603 }
35604 if (!argp2) {
35605 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35606 }
35607 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35608 }
35609 {
35610 PyThreadState* __tstate = wxPyBeginAllowThreads();
35611 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35612 wxPyEndAllowThreads(__tstate);
35613 if (PyErr_Occurred()) SWIG_fail;
35614 }
35615 {
35616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35617 }
35618 return resultobj;
35619 fail:
35620 return NULL;
35621 }
35622
35623
35624 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35625 PyObject *resultobj = 0;
35626 wxDisplay *arg1 = (wxDisplay *) 0 ;
35627 void *argp1 = 0 ;
35628 int res1 = 0 ;
35629 PyObject *swig_obj[1] ;
35630
35631 if (!args) SWIG_fail;
35632 swig_obj[0] = args;
35633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35634 if (!SWIG_IsOK(res1)) {
35635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35636 }
35637 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 wxDisplay_ResetMode(arg1);
35641 wxPyEndAllowThreads(__tstate);
35642 if (PyErr_Occurred()) SWIG_fail;
35643 }
35644 resultobj = SWIG_Py_Void();
35645 return resultobj;
35646 fail:
35647 return NULL;
35648 }
35649
35650
35651 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35652 PyObject *obj;
35653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35654 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35655 return SWIG_Py_Void();
35656 }
35657
35658 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35659 return SWIG_Python_InitShadowInstance(args);
35660 }
35661
35662 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35663 PyObject *resultobj = 0;
35664 wxStandardPaths *result = 0 ;
35665
35666 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 result = (wxStandardPaths *)wxStandardPaths_Get();
35670 wxPyEndAllowThreads(__tstate);
35671 if (PyErr_Occurred()) SWIG_fail;
35672 }
35673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35674 return resultobj;
35675 fail:
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35681 PyObject *resultobj = 0;
35682 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35683 wxString result;
35684 void *argp1 = 0 ;
35685 int res1 = 0 ;
35686 PyObject *swig_obj[1] ;
35687
35688 if (!args) SWIG_fail;
35689 swig_obj[0] = args;
35690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35691 if (!SWIG_IsOK(res1)) {
35692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35693 }
35694 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35698 wxPyEndAllowThreads(__tstate);
35699 if (PyErr_Occurred()) SWIG_fail;
35700 }
35701 {
35702 #if wxUSE_UNICODE
35703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35704 #else
35705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35706 #endif
35707 }
35708 return resultobj;
35709 fail:
35710 return NULL;
35711 }
35712
35713
35714 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35715 PyObject *resultobj = 0;
35716 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35717 wxString result;
35718 void *argp1 = 0 ;
35719 int res1 = 0 ;
35720 PyObject *swig_obj[1] ;
35721
35722 if (!args) SWIG_fail;
35723 swig_obj[0] = args;
35724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35725 if (!SWIG_IsOK(res1)) {
35726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35727 }
35728 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 {
35736 #if wxUSE_UNICODE
35737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35738 #else
35739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35740 #endif
35741 }
35742 return resultobj;
35743 fail:
35744 return NULL;
35745 }
35746
35747
35748 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35749 PyObject *resultobj = 0;
35750 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35751 wxString result;
35752 void *argp1 = 0 ;
35753 int res1 = 0 ;
35754 PyObject *swig_obj[1] ;
35755
35756 if (!args) SWIG_fail;
35757 swig_obj[0] = args;
35758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35759 if (!SWIG_IsOK(res1)) {
35760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35761 }
35762 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35763 {
35764 PyThreadState* __tstate = wxPyBeginAllowThreads();
35765 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 {
35770 #if wxUSE_UNICODE
35771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35772 #else
35773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35774 #endif
35775 }
35776 return resultobj;
35777 fail:
35778 return NULL;
35779 }
35780
35781
35782 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35783 PyObject *resultobj = 0;
35784 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35785 wxString result;
35786 void *argp1 = 0 ;
35787 int res1 = 0 ;
35788 PyObject *swig_obj[1] ;
35789
35790 if (!args) SWIG_fail;
35791 swig_obj[0] = args;
35792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35793 if (!SWIG_IsOK(res1)) {
35794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35795 }
35796 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35797 {
35798 PyThreadState* __tstate = wxPyBeginAllowThreads();
35799 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35800 wxPyEndAllowThreads(__tstate);
35801 if (PyErr_Occurred()) SWIG_fail;
35802 }
35803 {
35804 #if wxUSE_UNICODE
35805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35806 #else
35807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35808 #endif
35809 }
35810 return resultobj;
35811 fail:
35812 return NULL;
35813 }
35814
35815
35816 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35817 PyObject *resultobj = 0;
35818 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35819 wxString result;
35820 void *argp1 = 0 ;
35821 int res1 = 0 ;
35822 PyObject *swig_obj[1] ;
35823
35824 if (!args) SWIG_fail;
35825 swig_obj[0] = args;
35826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35827 if (!SWIG_IsOK(res1)) {
35828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35829 }
35830 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35831 {
35832 PyThreadState* __tstate = wxPyBeginAllowThreads();
35833 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35834 wxPyEndAllowThreads(__tstate);
35835 if (PyErr_Occurred()) SWIG_fail;
35836 }
35837 {
35838 #if wxUSE_UNICODE
35839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35840 #else
35841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35842 #endif
35843 }
35844 return resultobj;
35845 fail:
35846 return NULL;
35847 }
35848
35849
35850 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35851 PyObject *resultobj = 0;
35852 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35853 wxString result;
35854 void *argp1 = 0 ;
35855 int res1 = 0 ;
35856 PyObject *swig_obj[1] ;
35857
35858 if (!args) SWIG_fail;
35859 swig_obj[0] = args;
35860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35861 if (!SWIG_IsOK(res1)) {
35862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35863 }
35864 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35865 {
35866 PyThreadState* __tstate = wxPyBeginAllowThreads();
35867 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35868 wxPyEndAllowThreads(__tstate);
35869 if (PyErr_Occurred()) SWIG_fail;
35870 }
35871 {
35872 #if wxUSE_UNICODE
35873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35874 #else
35875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35876 #endif
35877 }
35878 return resultobj;
35879 fail:
35880 return NULL;
35881 }
35882
35883
35884 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35885 PyObject *resultobj = 0;
35886 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35887 wxString result;
35888 void *argp1 = 0 ;
35889 int res1 = 0 ;
35890 PyObject *swig_obj[1] ;
35891
35892 if (!args) SWIG_fail;
35893 swig_obj[0] = args;
35894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35895 if (!SWIG_IsOK(res1)) {
35896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35897 }
35898 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35899 {
35900 PyThreadState* __tstate = wxPyBeginAllowThreads();
35901 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35902 wxPyEndAllowThreads(__tstate);
35903 if (PyErr_Occurred()) SWIG_fail;
35904 }
35905 {
35906 #if wxUSE_UNICODE
35907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35908 #else
35909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35910 #endif
35911 }
35912 return resultobj;
35913 fail:
35914 return NULL;
35915 }
35916
35917
35918 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35919 PyObject *resultobj = 0;
35920 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35921 wxString result;
35922 void *argp1 = 0 ;
35923 int res1 = 0 ;
35924 PyObject *swig_obj[1] ;
35925
35926 if (!args) SWIG_fail;
35927 swig_obj[0] = args;
35928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35929 if (!SWIG_IsOK(res1)) {
35930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35931 }
35932 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35933 {
35934 PyThreadState* __tstate = wxPyBeginAllowThreads();
35935 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35936 wxPyEndAllowThreads(__tstate);
35937 if (PyErr_Occurred()) SWIG_fail;
35938 }
35939 {
35940 #if wxUSE_UNICODE
35941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35942 #else
35943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35944 #endif
35945 }
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35953 PyObject *resultobj = 0;
35954 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35955 wxString *arg2 = 0 ;
35956 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35957 wxString result;
35958 void *argp1 = 0 ;
35959 int res1 = 0 ;
35960 bool temp2 = false ;
35961 int val3 ;
35962 int ecode3 = 0 ;
35963 PyObject * obj0 = 0 ;
35964 PyObject * obj1 = 0 ;
35965 PyObject * obj2 = 0 ;
35966 char * kwnames[] = {
35967 (char *) "self",(char *) "lang",(char *) "category", NULL
35968 };
35969
35970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35972 if (!SWIG_IsOK(res1)) {
35973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35974 }
35975 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35976 {
35977 arg2 = wxString_in_helper(obj1);
35978 if (arg2 == NULL) SWIG_fail;
35979 temp2 = true;
35980 }
35981 if (obj2) {
35982 ecode3 = SWIG_AsVal_int(obj2, &val3);
35983 if (!SWIG_IsOK(ecode3)) {
35984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35985 }
35986 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35987 }
35988 {
35989 PyThreadState* __tstate = wxPyBeginAllowThreads();
35990 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35991 wxPyEndAllowThreads(__tstate);
35992 if (PyErr_Occurred()) SWIG_fail;
35993 }
35994 {
35995 #if wxUSE_UNICODE
35996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35997 #else
35998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35999 #endif
36000 }
36001 {
36002 if (temp2)
36003 delete arg2;
36004 }
36005 return resultobj;
36006 fail:
36007 {
36008 if (temp2)
36009 delete arg2;
36010 }
36011 return NULL;
36012 }
36013
36014
36015 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36016 PyObject *resultobj = 0;
36017 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36018 wxString result;
36019 void *argp1 = 0 ;
36020 int res1 = 0 ;
36021 PyObject *swig_obj[1] ;
36022
36023 if (!args) SWIG_fail;
36024 swig_obj[0] = args;
36025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36026 if (!SWIG_IsOK(res1)) {
36027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36028 }
36029 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36030 {
36031 PyThreadState* __tstate = wxPyBeginAllowThreads();
36032 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
36033 wxPyEndAllowThreads(__tstate);
36034 if (PyErr_Occurred()) SWIG_fail;
36035 }
36036 {
36037 #if wxUSE_UNICODE
36038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36039 #else
36040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36041 #endif
36042 }
36043 return resultobj;
36044 fail:
36045 return NULL;
36046 }
36047
36048
36049 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36050 PyObject *resultobj = 0;
36051 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36052 wxString *arg2 = 0 ;
36053 void *argp1 = 0 ;
36054 int res1 = 0 ;
36055 bool temp2 = false ;
36056 PyObject * obj0 = 0 ;
36057 PyObject * obj1 = 0 ;
36058 char * kwnames[] = {
36059 (char *) "self",(char *) "prefix", NULL
36060 };
36061
36062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
36063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36064 if (!SWIG_IsOK(res1)) {
36065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36066 }
36067 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36068 {
36069 arg2 = wxString_in_helper(obj1);
36070 if (arg2 == NULL) SWIG_fail;
36071 temp2 = true;
36072 }
36073 {
36074 PyThreadState* __tstate = wxPyBeginAllowThreads();
36075 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
36076 wxPyEndAllowThreads(__tstate);
36077 if (PyErr_Occurred()) SWIG_fail;
36078 }
36079 resultobj = SWIG_Py_Void();
36080 {
36081 if (temp2)
36082 delete arg2;
36083 }
36084 return resultobj;
36085 fail:
36086 {
36087 if (temp2)
36088 delete arg2;
36089 }
36090 return NULL;
36091 }
36092
36093
36094 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36095 PyObject *resultobj = 0;
36096 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36097 wxString result;
36098 void *argp1 = 0 ;
36099 int res1 = 0 ;
36100 PyObject *swig_obj[1] ;
36101
36102 if (!args) SWIG_fail;
36103 swig_obj[0] = args;
36104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36105 if (!SWIG_IsOK(res1)) {
36106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36107 }
36108 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36109 {
36110 PyThreadState* __tstate = wxPyBeginAllowThreads();
36111 result = wxStandardPaths_GetInstallPrefix(arg1);
36112 wxPyEndAllowThreads(__tstate);
36113 if (PyErr_Occurred()) SWIG_fail;
36114 }
36115 {
36116 #if wxUSE_UNICODE
36117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36118 #else
36119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36120 #endif
36121 }
36122 return resultobj;
36123 fail:
36124 return NULL;
36125 }
36126
36127
36128 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36129 PyObject *obj;
36130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36131 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36132 return SWIG_Py_Void();
36133 }
36134
36135 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36136 PyObject *resultobj = 0;
36137 wxEventType arg1 ;
36138 wxPowerEvent *result = 0 ;
36139 int val1 ;
36140 int ecode1 = 0 ;
36141 PyObject * obj0 = 0 ;
36142 char * kwnames[] = {
36143 (char *) "evtType", NULL
36144 };
36145
36146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36147 ecode1 = SWIG_AsVal_int(obj0, &val1);
36148 if (!SWIG_IsOK(ecode1)) {
36149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36150 }
36151 arg1 = static_cast< wxEventType >(val1);
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36159 return resultobj;
36160 fail:
36161 return NULL;
36162 }
36163
36164
36165 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36166 PyObject *resultobj = 0;
36167 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36168 void *argp1 = 0 ;
36169 int res1 = 0 ;
36170 PyObject *swig_obj[1] ;
36171
36172 if (!args) SWIG_fail;
36173 swig_obj[0] = args;
36174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36175 if (!SWIG_IsOK(res1)) {
36176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36177 }
36178 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36179 {
36180 PyThreadState* __tstate = wxPyBeginAllowThreads();
36181 (arg1)->Veto();
36182 wxPyEndAllowThreads(__tstate);
36183 if (PyErr_Occurred()) SWIG_fail;
36184 }
36185 resultobj = SWIG_Py_Void();
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36193 PyObject *resultobj = 0;
36194 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36195 bool result;
36196 void *argp1 = 0 ;
36197 int res1 = 0 ;
36198 PyObject *swig_obj[1] ;
36199
36200 if (!args) SWIG_fail;
36201 swig_obj[0] = args;
36202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36203 if (!SWIG_IsOK(res1)) {
36204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36205 }
36206 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36207 {
36208 PyThreadState* __tstate = wxPyBeginAllowThreads();
36209 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36210 wxPyEndAllowThreads(__tstate);
36211 if (PyErr_Occurred()) SWIG_fail;
36212 }
36213 {
36214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36215 }
36216 return resultobj;
36217 fail:
36218 return NULL;
36219 }
36220
36221
36222 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36223 PyObject *obj;
36224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36225 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36226 return SWIG_Py_Void();
36227 }
36228
36229 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36230 return SWIG_Python_InitShadowInstance(args);
36231 }
36232
36233 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36234 PyObject *resultobj = 0;
36235 wxPowerType result;
36236
36237 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36238 {
36239 PyThreadState* __tstate = wxPyBeginAllowThreads();
36240 result = (wxPowerType)wxGetPowerType();
36241 wxPyEndAllowThreads(__tstate);
36242 if (PyErr_Occurred()) SWIG_fail;
36243 }
36244 resultobj = SWIG_From_int(static_cast< int >(result));
36245 return resultobj;
36246 fail:
36247 return NULL;
36248 }
36249
36250
36251 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36252 PyObject *resultobj = 0;
36253 wxBatteryState result;
36254
36255 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36256 {
36257 PyThreadState* __tstate = wxPyBeginAllowThreads();
36258 result = (wxBatteryState)wxGetBatteryState();
36259 wxPyEndAllowThreads(__tstate);
36260 if (PyErr_Occurred()) SWIG_fail;
36261 }
36262 resultobj = SWIG_From_int(static_cast< int >(result));
36263 return resultobj;
36264 fail:
36265 return NULL;
36266 }
36267
36268
36269 static PyMethodDef SwigMethods[] = {
36270 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36271 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36274 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36275 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36277 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36278 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36280 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36281 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36282 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36285 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36286 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36287 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36289 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36291 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36292 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36293 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36294 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36295 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36296 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36297 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36298 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36299 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36300 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36301 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36302 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36309 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36310 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36311 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36312 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36313 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36314 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36316 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36317 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36326 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36328 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36329 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36330 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36331 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36332 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36333 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36334 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36335 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36336 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36337 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36338 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36340 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36341 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36342 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36343 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36347 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36348 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36349 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36350 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36351 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36352 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36353 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36354 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36355 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36356 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36357 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36358 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36359 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36369 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36370 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36371 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36372 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36373 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36374 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36375 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36376 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36377 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36378 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36379 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36381 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36383 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36384 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36386 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36387 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36388 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36389 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36390 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36391 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36392 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36393 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36394 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36395 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36396 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36397 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36398 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36399 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36402 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36404 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36405 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36407 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36408 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36410 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36411 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36412 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36413 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36414 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36415 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36416 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36418 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36419 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36420 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36421 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36423 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36424 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36425 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36426 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36427 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36429 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36432 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36434 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36436 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36437 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36438 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36440 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36441 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36442 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36444 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36445 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36447 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36448 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36449 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36450 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36451 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36452 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36453 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36454 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36455 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36458 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36459 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36463 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36464 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36466 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36468 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36469 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36470 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36471 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36472 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36473 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36474 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36475 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36477 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36478 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36479 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36480 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36481 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36483 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36484 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36485 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36486 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36487 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36490 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36491 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36492 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36494 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36495 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36496 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36498 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36500 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36501 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36502 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36503 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36504 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36505 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36506 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36507 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36508 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36509 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36510 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36511 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36512 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36513 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36514 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36515 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36516 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36518 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36519 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36520 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36521 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36522 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36525 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36526 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36527 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36529 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36530 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36534 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36535 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36536 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36537 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36538 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36539 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36540 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36541 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36542 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36546 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36555 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36557 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36558 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36559 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36560 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36561 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36563 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36564 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36565 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36571 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36572 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36573 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36574 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36575 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36576 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36577 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36578 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36579 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36580 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36581 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36582 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36584 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36585 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36586 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36587 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36588 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36589 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36590 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36591 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36593 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36595 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36596 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36597 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36598 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36599 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36600 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36601 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36602 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36603 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36604 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36606 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36607 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36608 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36609 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36610 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36611 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36612 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36613 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36614 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36615 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36616 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36617 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36618 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36619 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36620 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36621 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36622 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36623 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36624 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36625 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36626 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36627 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36628 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36629 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36630 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36631 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36632 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36633 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36634 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36635 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36636 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36637 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36638 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36639 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36640 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36641 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36642 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36643 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36644 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36645 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36649 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36650 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36651 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36652 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36653 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36656 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36657 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36658 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36659 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36661 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36662 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36664 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36667 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36668 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36669 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36670 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36672 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36673 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36674 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36676 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36677 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36678 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36679 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36680 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36681 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36682 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36683 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36684 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36685 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36686 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36688 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36689 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36690 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36691 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36692 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36693 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36694 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36700 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36702 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36703 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36705 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36707 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36710 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36712 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36716 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36717 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36718 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36719 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36720 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36721 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36723 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36725 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36727 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36728 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36729 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36730 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36731 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36734 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36735 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36737 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36738 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36740 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36742 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36761 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36763 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36765 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36767 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36768 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36770 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36771 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36772 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36773 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36775 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36776 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36777 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36778 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36779 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36780 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36781 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36782 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36783 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36784 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36785 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36786 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36788 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36789 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36790 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36800 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36804 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36805 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36806 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36807 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36813 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36814 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36819 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36825 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36826 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36827 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36834 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36838 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36841 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36842 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36843 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36844 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36845 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36846 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36847 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36848 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36849 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36850 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36854 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36857 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36858 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36859 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36860 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36864 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36865 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36866 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36871 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36872 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36874 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36875 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36877 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36878 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36881 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36882 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36883 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36885 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36886 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36887 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36888 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36889 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36891 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36896 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36898 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36900 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36902 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36903 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36904 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36905 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36906 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36907 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36909 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36910 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36911 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36913 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36914 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36915 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36916 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36917 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36918 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36919 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36920 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36921 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36922 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36923 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36925 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36926 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36927 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36928 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36929 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36930 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36931 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36933 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36935 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36936 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36938 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36939 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36940 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36941 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36942 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36943 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36944 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36945 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36946 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36947 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36948 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36949 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36950 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36951 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36952 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36953 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36954 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36955 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36956 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36957 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36958 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36959 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36960 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36961 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36962 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36963 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36964 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36965 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36966 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36967 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36968 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36969 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36970 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36971 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36972 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36973 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36974 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36975 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36976 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36977 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36978 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36979 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36980 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36981 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36982 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36983 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36984 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36985 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36986 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36988 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36989 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36990 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36991 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36992 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36993 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36994 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36995 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36996 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36997 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36998 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36999 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
37000 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
37001 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
37002 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
37003 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
37004 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
37005 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
37006 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37007 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
37008 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37009 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
37010 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
37011 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
37012 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37013 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
37014 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37015 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
37016 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37017 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
37018 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
37019 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37020 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
37021 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
37022 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37023 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37024 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
37025 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
37026 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
37027 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37028 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
37029 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
37030 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
37031 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37032 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
37033 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
37034 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
37035 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
37036 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
37037 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37038 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37039 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
37040 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
37041 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37042 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
37043 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37044 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
37045 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
37046 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37047 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37048 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
37049 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
37050 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
37051 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
37052 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
37053 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
37054 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
37055 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
37056 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37057 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
37058 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
37059 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
37060 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
37061 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
37062 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
37063 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
37064 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
37065 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
37066 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
37067 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
37068 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
37069 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
37070 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
37071 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
37072 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
37073 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37074 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
37075 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37076 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
37077 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37078 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37079 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
37080 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
37081 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
37082 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37083 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37084 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
37085 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
37086 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37087 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37088 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37089 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
37090 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37091 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
37092 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
37093 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
37094 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
37095 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
37096 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
37097 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37098 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
37099 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37100 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37101 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
37102 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37103 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37104 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
37105 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
37106 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
37107 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37108 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
37109 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37110 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37111 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
37112 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37113 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37114 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
37115 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
37116 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
37117 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
37118 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
37119 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
37120 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
37121 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
37122 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37123 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37124 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37125 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37126 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37127 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37128 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37129 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37130 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37131 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37132 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37133 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37134 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37135 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37136 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37137 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37138 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37139 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37140 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37141 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37142 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37143 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37144 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37145 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37146 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37147 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37148 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37149 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37150 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37151 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37152 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37153 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37154 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37155 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37156 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37157 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37158 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37159 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37160 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37161 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37162 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37163 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37164 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37165 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37166 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37167 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37168 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37169 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37170 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37171 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37172 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37173 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37174 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37175 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37176 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37177 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37178 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37179 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37180 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37181 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37182 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37183 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37184 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37185 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37186 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37187 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37188 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37189 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37190 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37191 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37192 { NULL, NULL, 0, NULL }
37193 };
37194
37195
37196 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37197
37198 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37199 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37200 }
37201 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37202 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37203 }
37204 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37205 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37206 }
37207 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37208 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37209 }
37210 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37211 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37212 }
37213 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37214 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37215 }
37216 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37217 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37218 }
37219 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37220 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37221 }
37222 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37223 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37224 }
37225 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37226 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37227 }
37228 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37229 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37230 }
37231 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37232 return (void *)((wxEvent *) ((wxPyEvent *) x));
37233 }
37234 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37235 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37236 }
37237 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37238 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37239 }
37240 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37241 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37242 }
37243 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37244 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37245 }
37246 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37247 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37248 }
37249 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37250 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37251 }
37252 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37253 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37254 }
37255 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37256 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37257 }
37258 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37259 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37260 }
37261 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37262 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37263 }
37264 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37265 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37266 }
37267 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37268 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37269 }
37270 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37271 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37272 }
37273 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37274 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37275 }
37276 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37277 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37278 }
37279 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37280 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37281 }
37282 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37283 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37284 }
37285 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37286 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37287 }
37288 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37289 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37290 }
37291 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37292 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37293 }
37294 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37295 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37296 }
37297 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37298 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37299 }
37300 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37301 return (void *)((wxEvent *) ((wxShowEvent *) x));
37302 }
37303 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37304 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37305 }
37306 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37307 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37308 }
37309 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37310 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37311 }
37312 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37313 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37314 }
37315 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37316 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37317 }
37318 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37319 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37320 }
37321 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37322 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37323 }
37324 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37325 return (void *)((wxConfigBase *) ((wxConfig *) x));
37326 }
37327 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37328 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37329 }
37330 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37331 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37332 }
37333 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37334 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37335 }
37336 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37337 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37338 }
37339 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37340 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37341 }
37342 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37343 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37344 }
37345 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37346 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37347 }
37348 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37349 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37350 }
37351 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37352 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37353 }
37354 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37355 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37356 }
37357 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37358 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37359 }
37360 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37361 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37362 }
37363 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37364 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37365 }
37366 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37367 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37368 }
37369 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37370 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37371 }
37372 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37373 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37374 }
37375 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37376 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37377 }
37378 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37379 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37380 }
37381 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37382 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37383 }
37384 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37385 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37386 }
37387 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37388 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37389 }
37390 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37391 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37392 }
37393 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37394 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37395 }
37396 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37397 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37398 }
37399 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37400 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37401 }
37402 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37403 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37404 }
37405 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37406 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37407 }
37408 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37409 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37410 }
37411 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37412 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37413 }
37414 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37415 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37416 }
37417 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37418 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37419 }
37420 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37421 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37422 }
37423 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37424 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37425 }
37426 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37427 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37428 }
37429 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37430 return (void *)((wxObject *) ((wxSizerItem *) x));
37431 }
37432 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37433 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37434 }
37435 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37436 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37437 }
37438 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37439 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37440 }
37441 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37442 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37443 }
37444 static void *_p_wxSizerTo_p_wxObject(void *x) {
37445 return (void *)((wxObject *) ((wxSizer *) x));
37446 }
37447 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37448 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37449 }
37450 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37451 return (void *)((wxObject *) ((wxFileHistory *) x));
37452 }
37453 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37454 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37455 }
37456 static void *_p_wxEventTo_p_wxObject(void *x) {
37457 return (void *)((wxObject *) ((wxEvent *) x));
37458 }
37459 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37460 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37461 }
37462 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37463 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37464 }
37465 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37466 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37467 }
37468 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37469 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37470 }
37471 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37472 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37473 }
37474 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37475 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37476 }
37477 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37478 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37479 }
37480 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37481 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37482 }
37483 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37484 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37485 }
37486 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37487 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37488 }
37489 static void *_p_wxControlTo_p_wxObject(void *x) {
37490 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37491 }
37492 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37493 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37494 }
37495 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37496 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37497 }
37498 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37499 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37500 }
37501 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37502 return (void *)((wxObject *) ((wxFSFile *) x));
37503 }
37504 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37505 return (void *)((wxObject *) ((wxClipboard *) x));
37506 }
37507 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37508 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37509 }
37510 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37511 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37512 }
37513 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37514 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37515 }
37516 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37517 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37518 }
37519 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37520 return (void *)((wxObject *) ((wxToolTip *) x));
37521 }
37522 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37523 return (void *)((wxObject *) ((wxMenuItem *) x));
37524 }
37525 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37526 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37527 }
37528 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37529 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37530 }
37531 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37532 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37533 }
37534 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37535 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37536 }
37537 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37538 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37539 }
37540 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37541 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37542 }
37543 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37544 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37545 }
37546 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37547 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37548 }
37549 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37550 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37551 }
37552 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37553 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37554 }
37555 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37556 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37557 }
37558 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37559 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37560 }
37561 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37562 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37563 }
37564 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37565 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37566 }
37567 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37568 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37569 }
37570 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37571 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37572 }
37573 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37574 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37575 }
37576 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37577 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37578 }
37579 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37580 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37581 }
37582 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37583 return (void *)((wxObject *) ((wxImageHandler *) x));
37584 }
37585 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37586 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37587 }
37588 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37589 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37590 }
37591 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37592 return (void *)((wxObject *) ((wxEvtHandler *) x));
37593 }
37594 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37595 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37596 }
37597 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37598 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37599 }
37600 static void *_p_wxImageTo_p_wxObject(void *x) {
37601 return (void *)((wxObject *) ((wxImage *) x));
37602 }
37603 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37604 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37605 }
37606 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37607 return (void *)((wxObject *) ((wxSystemOptions *) x));
37608 }
37609 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37610 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37611 }
37612 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37613 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37614 }
37615 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37616 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37617 }
37618 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37619 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37620 }
37621 static void *_p_wxWindowTo_p_wxObject(void *x) {
37622 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37623 }
37624 static void *_p_wxMenuTo_p_wxObject(void *x) {
37625 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37626 }
37627 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37628 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37629 }
37630 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37631 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37632 }
37633 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37634 return (void *)((wxObject *) ((wxFileSystem *) x));
37635 }
37636 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37637 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37638 }
37639 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37640 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37641 }
37642 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37643 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37644 }
37645 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37646 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37647 }
37648 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37649 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37650 }
37651 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37652 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37653 }
37654 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37655 return (void *)((wxObject *) ((wxBusyInfo *) x));
37656 }
37657 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37658 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37659 }
37660 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37661 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37662 }
37663 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37664 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37665 }
37666 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37667 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37668 }
37669 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37670 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37671 }
37672 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37673 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37674 }
37675 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37676 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37677 }
37678 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37679 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37680 }
37681 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37682 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37683 }
37684 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37685 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37686 }
37687 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37688 return (void *)((wxLog *) ((wxLogBuffer *) x));
37689 }
37690 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37691 return (void *)((wxLog *) ((wxLogStderr *) x));
37692 }
37693 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37694 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37695 }
37696 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37697 return (void *)((wxLog *) ((wxLogWindow *) x));
37698 }
37699 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37700 return (void *)((wxLog *) ((wxLogChain *) x));
37701 }
37702 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37703 return (void *)((wxLog *) ((wxLogGui *) x));
37704 }
37705 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37706 return (void *)((wxLog *) ((wxPyLog *) x));
37707 }
37708 static void *_p_wxControlTo_p_wxWindow(void *x) {
37709 return (void *)((wxWindow *) ((wxControl *) x));
37710 }
37711 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37712 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37713 }
37714 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37715 return (void *)((wxWindow *) ((wxMenuBar *) x));
37716 }
37717 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37718 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37719 }
37720 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37721 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37722 }
37723 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37724 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};
37725 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37726 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37727 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37728 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37729 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37730 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37731 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37732 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37733 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37734 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37735 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37736 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37737 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37738 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37739 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37740 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37741 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37742 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37743 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37744 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37745 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37746 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37747 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37748 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37749 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37750 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37751 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37752 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37753 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37754 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37755 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37756 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37757 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37758 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37759 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37760 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37761 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37762 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37763 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37764 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37765 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37766 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37767 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37768 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37769 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37770 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37771 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37772 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37773 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37774 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37775 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37776 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37777 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37778 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37779 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37780 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37781 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37782 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37783 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37784 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37785 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37786 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37787 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37788 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37789 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37790 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37791 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37792 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37793 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37794 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37795 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37796 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37797 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37798 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37799 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37800 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37801 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37802 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37803 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37804 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37805 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37806 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37807 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37808 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37809 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37810 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37811 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37812 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37813 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37814 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37815 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37816 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37817 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37818 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37819 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37820 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37821 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37822 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37823 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37824 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37825 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37826 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37827 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37828 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37829 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37830 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37831 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37832 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37833 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37834 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37835 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37836 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37837 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37838 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37839 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37840 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37841 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37842 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37843 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37844 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37845 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37846 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37847 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37848 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37849 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37850 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37851 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37852 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37853 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37854 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37855 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37856 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37857 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37858 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37859 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37860 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37861 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37862 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37863 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37864 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37865 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37866 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37867 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37868 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37869 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37870 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37871 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37872 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37873 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37874 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37875 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37876 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37877 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37878 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37879 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37880 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37881 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37882 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37883 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37884 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37885 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37886 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37887 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37888 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37889 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37890 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37891 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37892 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37893 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37894 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37895
37896 static swig_type_info *swig_type_initial[] = {
37897 &_swigt__p_char,
37898 &_swigt__p_form_ops_t,
37899 &_swigt__p_int,
37900 &_swigt__p_unsigned_char,
37901 &_swigt__p_unsigned_int,
37902 &_swigt__p_unsigned_long,
37903 &_swigt__p_void,
37904 &_swigt__p_wxANIHandler,
37905 &_swigt__p_wxAcceleratorTable,
37906 &_swigt__p_wxActivateEvent,
37907 &_swigt__p_wxArrayString,
37908 &_swigt__p_wxBMPHandler,
37909 &_swigt__p_wxBitmap,
37910 &_swigt__p_wxBitmapDataObject,
37911 &_swigt__p_wxBoxSizer,
37912 &_swigt__p_wxBusyCursor,
37913 &_swigt__p_wxBusyInfo,
37914 &_swigt__p_wxCURHandler,
37915 &_swigt__p_wxCaret,
37916 &_swigt__p_wxChar,
37917 &_swigt__p_wxChildFocusEvent,
37918 &_swigt__p_wxClipboard,
37919 &_swigt__p_wxClipboardLocker,
37920 &_swigt__p_wxClipboardTextEvent,
37921 &_swigt__p_wxCloseEvent,
37922 &_swigt__p_wxColour,
37923 &_swigt__p_wxCommandEvent,
37924 &_swigt__p_wxConfig,
37925 &_swigt__p_wxConfigBase,
37926 &_swigt__p_wxConfigPathChanger,
37927 &_swigt__p_wxContextMenuEvent,
37928 &_swigt__p_wxControl,
37929 &_swigt__p_wxControlWithItems,
37930 &_swigt__p_wxCursor,
37931 &_swigt__p_wxCustomDataObject,
37932 &_swigt__p_wxDC,
37933 &_swigt__p_wxDataFormat,
37934 &_swigt__p_wxDataObject,
37935 &_swigt__p_wxDataObjectComposite,
37936 &_swigt__p_wxDataObjectSimple,
37937 &_swigt__p_wxDateEvent,
37938 &_swigt__p_wxDateSpan,
37939 &_swigt__p_wxDateTime,
37940 &_swigt__p_wxDateTime__TimeZone,
37941 &_swigt__p_wxDisplay,
37942 &_swigt__p_wxDisplayChangedEvent,
37943 &_swigt__p_wxDropFilesEvent,
37944 &_swigt__p_wxDuplexMode,
37945 &_swigt__p_wxEraseEvent,
37946 &_swigt__p_wxEvent,
37947 &_swigt__p_wxEvtHandler,
37948 &_swigt__p_wxFSFile,
37949 &_swigt__p_wxFileConfig,
37950 &_swigt__p_wxFileDataObject,
37951 &_swigt__p_wxFileHistory,
37952 &_swigt__p_wxFileSystem,
37953 &_swigt__p_wxFileType,
37954 &_swigt__p_wxFileTypeInfo,
37955 &_swigt__p_wxFlexGridSizer,
37956 &_swigt__p_wxFocusEvent,
37957 &_swigt__p_wxFont,
37958 &_swigt__p_wxFrame,
37959 &_swigt__p_wxGBSizerItem,
37960 &_swigt__p_wxGIFHandler,
37961 &_swigt__p_wxGridBagSizer,
37962 &_swigt__p_wxGridSizer,
37963 &_swigt__p_wxICOHandler,
37964 &_swigt__p_wxIcon,
37965 &_swigt__p_wxIconizeEvent,
37966 &_swigt__p_wxIdleEvent,
37967 &_swigt__p_wxImage,
37968 &_swigt__p_wxImageHandler,
37969 &_swigt__p_wxIndividualLayoutConstraint,
37970 &_swigt__p_wxInitDialogEvent,
37971 &_swigt__p_wxJPEGHandler,
37972 &_swigt__p_wxJoystick,
37973 &_swigt__p_wxJoystickEvent,
37974 &_swigt__p_wxKeyEvent,
37975 &_swigt__p_wxKillError,
37976 &_swigt__p_wxLayoutConstraints,
37977 &_swigt__p_wxLog,
37978 &_swigt__p_wxLogBuffer,
37979 &_swigt__p_wxLogChain,
37980 &_swigt__p_wxLogGui,
37981 &_swigt__p_wxLogNull,
37982 &_swigt__p_wxLogStderr,
37983 &_swigt__p_wxLogTextCtrl,
37984 &_swigt__p_wxLogWindow,
37985 &_swigt__p_wxMaximizeEvent,
37986 &_swigt__p_wxMemorySize,
37987 &_swigt__p_wxMenu,
37988 &_swigt__p_wxMenuBar,
37989 &_swigt__p_wxMenuEvent,
37990 &_swigt__p_wxMenuItem,
37991 &_swigt__p_wxMetafile,
37992 &_swigt__p_wxMetafileDataObject,
37993 &_swigt__p_wxMimeTypesManager,
37994 &_swigt__p_wxMouseCaptureChangedEvent,
37995 &_swigt__p_wxMouseEvent,
37996 &_swigt__p_wxMouseState,
37997 &_swigt__p_wxMoveEvent,
37998 &_swigt__p_wxMutexGuiLocker,
37999 &_swigt__p_wxNavigationKeyEvent,
38000 &_swigt__p_wxNcPaintEvent,
38001 &_swigt__p_wxNotifyEvent,
38002 &_swigt__p_wxObject,
38003 &_swigt__p_wxOutputStream,
38004 &_swigt__p_wxPCXHandler,
38005 &_swigt__p_wxPNGHandler,
38006 &_swigt__p_wxPNMHandler,
38007 &_swigt__p_wxPaintEvent,
38008 &_swigt__p_wxPaletteChangedEvent,
38009 &_swigt__p_wxPaperSize,
38010 &_swigt__p_wxPoint,
38011 &_swigt__p_wxPowerEvent,
38012 &_swigt__p_wxProcessEvent,
38013 &_swigt__p_wxPyApp,
38014 &_swigt__p_wxPyArtProvider,
38015 &_swigt__p_wxPyBitmapDataObject,
38016 &_swigt__p_wxPyCommandEvent,
38017 &_swigt__p_wxPyDataObjectSimple,
38018 &_swigt__p_wxPyDropSource,
38019 &_swigt__p_wxPyDropTarget,
38020 &_swigt__p_wxPyEvent,
38021 &_swigt__p_wxPyFileDropTarget,
38022 &_swigt__p_wxPyImageHandler,
38023 &_swigt__p_wxPyLog,
38024 &_swigt__p_wxPyProcess,
38025 &_swigt__p_wxPySizer,
38026 &_swigt__p_wxPyTextDataObject,
38027 &_swigt__p_wxPyTextDropTarget,
38028 &_swigt__p_wxPyTimer,
38029 &_swigt__p_wxPyTipProvider,
38030 &_swigt__p_wxPyValidator,
38031 &_swigt__p_wxQueryNewPaletteEvent,
38032 &_swigt__p_wxRect,
38033 &_swigt__p_wxScrollEvent,
38034 &_swigt__p_wxScrollWinEvent,
38035 &_swigt__p_wxSetCursorEvent,
38036 &_swigt__p_wxShowEvent,
38037 &_swigt__p_wxSingleInstanceChecker,
38038 &_swigt__p_wxSize,
38039 &_swigt__p_wxSizeEvent,
38040 &_swigt__p_wxSizer,
38041 &_swigt__p_wxSizerItem,
38042 &_swigt__p_wxSound,
38043 &_swigt__p_wxStandardPaths,
38044 &_swigt__p_wxStaticBoxSizer,
38045 &_swigt__p_wxStdDialogButtonSizer,
38046 &_swigt__p_wxStopWatch,
38047 &_swigt__p_wxString,
38048 &_swigt__p_wxSysColourChangedEvent,
38049 &_swigt__p_wxSystemOptions,
38050 &_swigt__p_wxSystemSettings,
38051 &_swigt__p_wxTIFFHandler,
38052 &_swigt__p_wxTextCtrl,
38053 &_swigt__p_wxTextDataObject,
38054 &_swigt__p_wxTimeSpan,
38055 &_swigt__p_wxTimer,
38056 &_swigt__p_wxTimerEvent,
38057 &_swigt__p_wxTimerRunner,
38058 &_swigt__p_wxTipProvider,
38059 &_swigt__p_wxToolTip,
38060 &_swigt__p_wxURLDataObject,
38061 &_swigt__p_wxUpdateUIEvent,
38062 &_swigt__p_wxValidator,
38063 &_swigt__p_wxVideoMode,
38064 &_swigt__p_wxWindow,
38065 &_swigt__p_wxWindowCreateEvent,
38066 &_swigt__p_wxWindowDestroyEvent,
38067 &_swigt__p_wxWindowDisabler,
38068 &_swigt__p_wxXPMHandler,
38069 };
38070
38071 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
38072 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
38073 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
38074 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
38075 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
38076 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
38077 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
38078 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
38079 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
38080 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}};
38081 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
38082 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
38083 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
38084 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
38085 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
38086 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
38087 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
38088 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
38089 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}};
38090 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
38091 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
38092 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
38093 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
38094 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
38095 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}};
38096 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
38097 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}};
38098 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
38099 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
38100 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
38101 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
38102 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
38103 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38104 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38105 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
38106 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
38107 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
38108 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
38109 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
38110 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
38111 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
38112 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
38113 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
38114 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
38115 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
38116 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38117 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38118 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
38119 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38120 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
38121 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
38122 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38123 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38124 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38125 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38126 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38127 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38128 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38129 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38130 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38131 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38132 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38133 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38134 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38135 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38136 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38137 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38138 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38139 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38140 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}};
38141 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38142 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38143 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38144 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38145 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38146 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38147 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}};
38148 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38149 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38150 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38151 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38152 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38153 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38154 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38155 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38156 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38157 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38158 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38159 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}};
38160 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38161 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38162 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38163 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38164 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38165 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38166 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38167 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
38168 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38169 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
38170 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38171 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38172 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38173 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38174 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38175 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38176 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38177 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38178 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38179 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38180 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38181 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38182 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38183 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38184 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38185 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38186 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38187 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38188 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38189 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38190 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38191 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38192 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38193 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38194 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38195 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38196 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38197 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38198 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38199 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38200 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38201 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38202 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38203 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38204 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}};
38205 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38206 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38207 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38208 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38209 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38210 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38211 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38212 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38213 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38214 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}};
38215 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38216 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38217 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38218 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38219 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38220 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38221 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38222 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38223 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38224 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38225 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38226 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38227 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38228 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38229 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38230 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38231 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38232 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}};
38233 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38234 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38235 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38236 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38237 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}};
38238 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38239 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38240 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38241 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}};
38242 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38243
38244 static swig_cast_info *swig_cast_initial[] = {
38245 _swigc__p_char,
38246 _swigc__p_form_ops_t,
38247 _swigc__p_int,
38248 _swigc__p_unsigned_char,
38249 _swigc__p_unsigned_int,
38250 _swigc__p_unsigned_long,
38251 _swigc__p_void,
38252 _swigc__p_wxANIHandler,
38253 _swigc__p_wxAcceleratorTable,
38254 _swigc__p_wxActivateEvent,
38255 _swigc__p_wxArrayString,
38256 _swigc__p_wxBMPHandler,
38257 _swigc__p_wxBitmap,
38258 _swigc__p_wxBitmapDataObject,
38259 _swigc__p_wxBoxSizer,
38260 _swigc__p_wxBusyCursor,
38261 _swigc__p_wxBusyInfo,
38262 _swigc__p_wxCURHandler,
38263 _swigc__p_wxCaret,
38264 _swigc__p_wxChar,
38265 _swigc__p_wxChildFocusEvent,
38266 _swigc__p_wxClipboard,
38267 _swigc__p_wxClipboardLocker,
38268 _swigc__p_wxClipboardTextEvent,
38269 _swigc__p_wxCloseEvent,
38270 _swigc__p_wxColour,
38271 _swigc__p_wxCommandEvent,
38272 _swigc__p_wxConfig,
38273 _swigc__p_wxConfigBase,
38274 _swigc__p_wxConfigPathChanger,
38275 _swigc__p_wxContextMenuEvent,
38276 _swigc__p_wxControl,
38277 _swigc__p_wxControlWithItems,
38278 _swigc__p_wxCursor,
38279 _swigc__p_wxCustomDataObject,
38280 _swigc__p_wxDC,
38281 _swigc__p_wxDataFormat,
38282 _swigc__p_wxDataObject,
38283 _swigc__p_wxDataObjectComposite,
38284 _swigc__p_wxDataObjectSimple,
38285 _swigc__p_wxDateEvent,
38286 _swigc__p_wxDateSpan,
38287 _swigc__p_wxDateTime,
38288 _swigc__p_wxDateTime__TimeZone,
38289 _swigc__p_wxDisplay,
38290 _swigc__p_wxDisplayChangedEvent,
38291 _swigc__p_wxDropFilesEvent,
38292 _swigc__p_wxDuplexMode,
38293 _swigc__p_wxEraseEvent,
38294 _swigc__p_wxEvent,
38295 _swigc__p_wxEvtHandler,
38296 _swigc__p_wxFSFile,
38297 _swigc__p_wxFileConfig,
38298 _swigc__p_wxFileDataObject,
38299 _swigc__p_wxFileHistory,
38300 _swigc__p_wxFileSystem,
38301 _swigc__p_wxFileType,
38302 _swigc__p_wxFileTypeInfo,
38303 _swigc__p_wxFlexGridSizer,
38304 _swigc__p_wxFocusEvent,
38305 _swigc__p_wxFont,
38306 _swigc__p_wxFrame,
38307 _swigc__p_wxGBSizerItem,
38308 _swigc__p_wxGIFHandler,
38309 _swigc__p_wxGridBagSizer,
38310 _swigc__p_wxGridSizer,
38311 _swigc__p_wxICOHandler,
38312 _swigc__p_wxIcon,
38313 _swigc__p_wxIconizeEvent,
38314 _swigc__p_wxIdleEvent,
38315 _swigc__p_wxImage,
38316 _swigc__p_wxImageHandler,
38317 _swigc__p_wxIndividualLayoutConstraint,
38318 _swigc__p_wxInitDialogEvent,
38319 _swigc__p_wxJPEGHandler,
38320 _swigc__p_wxJoystick,
38321 _swigc__p_wxJoystickEvent,
38322 _swigc__p_wxKeyEvent,
38323 _swigc__p_wxKillError,
38324 _swigc__p_wxLayoutConstraints,
38325 _swigc__p_wxLog,
38326 _swigc__p_wxLogBuffer,
38327 _swigc__p_wxLogChain,
38328 _swigc__p_wxLogGui,
38329 _swigc__p_wxLogNull,
38330 _swigc__p_wxLogStderr,
38331 _swigc__p_wxLogTextCtrl,
38332 _swigc__p_wxLogWindow,
38333 _swigc__p_wxMaximizeEvent,
38334 _swigc__p_wxMemorySize,
38335 _swigc__p_wxMenu,
38336 _swigc__p_wxMenuBar,
38337 _swigc__p_wxMenuEvent,
38338 _swigc__p_wxMenuItem,
38339 _swigc__p_wxMetafile,
38340 _swigc__p_wxMetafileDataObject,
38341 _swigc__p_wxMimeTypesManager,
38342 _swigc__p_wxMouseCaptureChangedEvent,
38343 _swigc__p_wxMouseEvent,
38344 _swigc__p_wxMouseState,
38345 _swigc__p_wxMoveEvent,
38346 _swigc__p_wxMutexGuiLocker,
38347 _swigc__p_wxNavigationKeyEvent,
38348 _swigc__p_wxNcPaintEvent,
38349 _swigc__p_wxNotifyEvent,
38350 _swigc__p_wxObject,
38351 _swigc__p_wxOutputStream,
38352 _swigc__p_wxPCXHandler,
38353 _swigc__p_wxPNGHandler,
38354 _swigc__p_wxPNMHandler,
38355 _swigc__p_wxPaintEvent,
38356 _swigc__p_wxPaletteChangedEvent,
38357 _swigc__p_wxPaperSize,
38358 _swigc__p_wxPoint,
38359 _swigc__p_wxPowerEvent,
38360 _swigc__p_wxProcessEvent,
38361 _swigc__p_wxPyApp,
38362 _swigc__p_wxPyArtProvider,
38363 _swigc__p_wxPyBitmapDataObject,
38364 _swigc__p_wxPyCommandEvent,
38365 _swigc__p_wxPyDataObjectSimple,
38366 _swigc__p_wxPyDropSource,
38367 _swigc__p_wxPyDropTarget,
38368 _swigc__p_wxPyEvent,
38369 _swigc__p_wxPyFileDropTarget,
38370 _swigc__p_wxPyImageHandler,
38371 _swigc__p_wxPyLog,
38372 _swigc__p_wxPyProcess,
38373 _swigc__p_wxPySizer,
38374 _swigc__p_wxPyTextDataObject,
38375 _swigc__p_wxPyTextDropTarget,
38376 _swigc__p_wxPyTimer,
38377 _swigc__p_wxPyTipProvider,
38378 _swigc__p_wxPyValidator,
38379 _swigc__p_wxQueryNewPaletteEvent,
38380 _swigc__p_wxRect,
38381 _swigc__p_wxScrollEvent,
38382 _swigc__p_wxScrollWinEvent,
38383 _swigc__p_wxSetCursorEvent,
38384 _swigc__p_wxShowEvent,
38385 _swigc__p_wxSingleInstanceChecker,
38386 _swigc__p_wxSize,
38387 _swigc__p_wxSizeEvent,
38388 _swigc__p_wxSizer,
38389 _swigc__p_wxSizerItem,
38390 _swigc__p_wxSound,
38391 _swigc__p_wxStandardPaths,
38392 _swigc__p_wxStaticBoxSizer,
38393 _swigc__p_wxStdDialogButtonSizer,
38394 _swigc__p_wxStopWatch,
38395 _swigc__p_wxString,
38396 _swigc__p_wxSysColourChangedEvent,
38397 _swigc__p_wxSystemOptions,
38398 _swigc__p_wxSystemSettings,
38399 _swigc__p_wxTIFFHandler,
38400 _swigc__p_wxTextCtrl,
38401 _swigc__p_wxTextDataObject,
38402 _swigc__p_wxTimeSpan,
38403 _swigc__p_wxTimer,
38404 _swigc__p_wxTimerEvent,
38405 _swigc__p_wxTimerRunner,
38406 _swigc__p_wxTipProvider,
38407 _swigc__p_wxToolTip,
38408 _swigc__p_wxURLDataObject,
38409 _swigc__p_wxUpdateUIEvent,
38410 _swigc__p_wxValidator,
38411 _swigc__p_wxVideoMode,
38412 _swigc__p_wxWindow,
38413 _swigc__p_wxWindowCreateEvent,
38414 _swigc__p_wxWindowDestroyEvent,
38415 _swigc__p_wxWindowDisabler,
38416 _swigc__p_wxXPMHandler,
38417 };
38418
38419
38420 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38421
38422 static swig_const_info swig_const_table[] = {
38423 {0, 0, 0, 0.0, 0, 0}};
38424
38425 #ifdef __cplusplus
38426 }
38427 #endif
38428 /* -----------------------------------------------------------------------------
38429 * Type initialization:
38430 * This problem is tough by the requirement that no dynamic
38431 * memory is used. Also, since swig_type_info structures store pointers to
38432 * swig_cast_info structures and swig_cast_info structures store pointers back
38433 * to swig_type_info structures, we need some lookup code at initialization.
38434 * The idea is that swig generates all the structures that are needed.
38435 * The runtime then collects these partially filled structures.
38436 * The SWIG_InitializeModule function takes these initial arrays out of
38437 * swig_module, and does all the lookup, filling in the swig_module.types
38438 * array with the correct data and linking the correct swig_cast_info
38439 * structures together.
38440 *
38441 * The generated swig_type_info structures are assigned staticly to an initial
38442 * array. We just loop though that array, and handle each type individually.
38443 * First we lookup if this type has been already loaded, and if so, use the
38444 * loaded structure instead of the generated one. Then we have to fill in the
38445 * cast linked list. The cast data is initially stored in something like a
38446 * two-dimensional array. Each row corresponds to a type (there are the same
38447 * number of rows as there are in the swig_type_initial array). Each entry in
38448 * a column is one of the swig_cast_info structures for that type.
38449 * The cast_initial array is actually an array of arrays, because each row has
38450 * a variable number of columns. So to actually build the cast linked list,
38451 * we find the array of casts associated with the type, and loop through it
38452 * adding the casts to the list. The one last trick we need to do is making
38453 * sure the type pointer in the swig_cast_info struct is correct.
38454 *
38455 * First off, we lookup the cast->type name to see if it is already loaded.
38456 * There are three cases to handle:
38457 * 1) If the cast->type has already been loaded AND the type we are adding
38458 * casting info to has not been loaded (it is in this module), THEN we
38459 * replace the cast->type pointer with the type pointer that has already
38460 * been loaded.
38461 * 2) If BOTH types (the one we are adding casting info to, and the
38462 * cast->type) are loaded, THEN the cast info has already been loaded by
38463 * the previous module so we just ignore it.
38464 * 3) Finally, if cast->type has not already been loaded, then we add that
38465 * swig_cast_info to the linked list (because the cast->type) pointer will
38466 * be correct.
38467 * ----------------------------------------------------------------------------- */
38468
38469 #ifdef __cplusplus
38470 extern "C" {
38471 #if 0
38472 } /* c-mode */
38473 #endif
38474 #endif
38475
38476 #if 0
38477 #define SWIGRUNTIME_DEBUG
38478 #endif
38479
38480 SWIGRUNTIME void
38481 SWIG_InitializeModule(void *clientdata) {
38482 size_t i;
38483 swig_module_info *module_head;
38484 static int init_run = 0;
38485
38486 clientdata = clientdata;
38487
38488 if (init_run) return;
38489 init_run = 1;
38490
38491 /* Initialize the swig_module */
38492 swig_module.type_initial = swig_type_initial;
38493 swig_module.cast_initial = swig_cast_initial;
38494
38495 /* Try and load any already created modules */
38496 module_head = SWIG_GetModule(clientdata);
38497 if (module_head) {
38498 swig_module.next = module_head->next;
38499 module_head->next = &swig_module;
38500 } else {
38501 /* This is the first module loaded */
38502 swig_module.next = &swig_module;
38503 SWIG_SetModule(clientdata, &swig_module);
38504 }
38505
38506 /* Now work on filling in swig_module.types */
38507 #ifdef SWIGRUNTIME_DEBUG
38508 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38509 #endif
38510 for (i = 0; i < swig_module.size; ++i) {
38511 swig_type_info *type = 0;
38512 swig_type_info *ret;
38513 swig_cast_info *cast;
38514
38515 #ifdef SWIGRUNTIME_DEBUG
38516 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38517 #endif
38518
38519 /* if there is another module already loaded */
38520 if (swig_module.next != &swig_module) {
38521 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38522 }
38523 if (type) {
38524 /* Overwrite clientdata field */
38525 #ifdef SWIGRUNTIME_DEBUG
38526 printf("SWIG_InitializeModule: found type %s\n", type->name);
38527 #endif
38528 if (swig_module.type_initial[i]->clientdata) {
38529 type->clientdata = swig_module.type_initial[i]->clientdata;
38530 #ifdef SWIGRUNTIME_DEBUG
38531 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38532 #endif
38533 }
38534 } else {
38535 type = swig_module.type_initial[i];
38536 }
38537
38538 /* Insert casting types */
38539 cast = swig_module.cast_initial[i];
38540 while (cast->type) {
38541 /* Don't need to add information already in the list */
38542 ret = 0;
38543 #ifdef SWIGRUNTIME_DEBUG
38544 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38545 #endif
38546 if (swig_module.next != &swig_module) {
38547 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38548 #ifdef SWIGRUNTIME_DEBUG
38549 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38550 #endif
38551 }
38552 if (ret) {
38553 if (type == swig_module.type_initial[i]) {
38554 #ifdef SWIGRUNTIME_DEBUG
38555 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38556 #endif
38557 cast->type = ret;
38558 ret = 0;
38559 } else {
38560 /* Check for casting already in the list */
38561 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38562 #ifdef SWIGRUNTIME_DEBUG
38563 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38564 #endif
38565 if (!ocast) ret = 0;
38566 }
38567 }
38568
38569 if (!ret) {
38570 #ifdef SWIGRUNTIME_DEBUG
38571 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38572 #endif
38573 if (type->cast) {
38574 type->cast->prev = cast;
38575 cast->next = type->cast;
38576 }
38577 type->cast = cast;
38578 }
38579 cast++;
38580 }
38581 /* Set entry in modules->types array equal to the type */
38582 swig_module.types[i] = type;
38583 }
38584 swig_module.types[i] = 0;
38585
38586 #ifdef SWIGRUNTIME_DEBUG
38587 printf("**** SWIG_InitializeModule: Cast List ******\n");
38588 for (i = 0; i < swig_module.size; ++i) {
38589 int j = 0;
38590 swig_cast_info *cast = swig_module.cast_initial[i];
38591 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38592 while (cast->type) {
38593 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38594 cast++;
38595 ++j;
38596 }
38597 printf("---- Total casts: %d\n",j);
38598 }
38599 printf("**** SWIG_InitializeModule: Cast List ******\n");
38600 #endif
38601 }
38602
38603 /* This function will propagate the clientdata field of type to
38604 * any new swig_type_info structures that have been added into the list
38605 * of equivalent types. It is like calling
38606 * SWIG_TypeClientData(type, clientdata) a second time.
38607 */
38608 SWIGRUNTIME void
38609 SWIG_PropagateClientData(void) {
38610 size_t i;
38611 swig_cast_info *equiv;
38612 static int init_run = 0;
38613
38614 if (init_run) return;
38615 init_run = 1;
38616
38617 for (i = 0; i < swig_module.size; i++) {
38618 if (swig_module.types[i]->clientdata) {
38619 equiv = swig_module.types[i]->cast;
38620 while (equiv) {
38621 if (!equiv->converter) {
38622 if (equiv->type && !equiv->type->clientdata)
38623 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38624 }
38625 equiv = equiv->next;
38626 }
38627 }
38628 }
38629 }
38630
38631 #ifdef __cplusplus
38632 #if 0
38633 {
38634 /* c-mode */
38635 #endif
38636 }
38637 #endif
38638
38639
38640
38641 #ifdef __cplusplus
38642 extern "C" {
38643 #endif
38644
38645 /* Python-specific SWIG API */
38646 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38647 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38648 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38649
38650 /* -----------------------------------------------------------------------------
38651 * global variable support code.
38652 * ----------------------------------------------------------------------------- */
38653
38654 typedef struct swig_globalvar {
38655 char *name; /* Name of global variable */
38656 PyObject *(*get_attr)(void); /* Return the current value */
38657 int (*set_attr)(PyObject *); /* Set the value */
38658 struct swig_globalvar *next;
38659 } swig_globalvar;
38660
38661 typedef struct swig_varlinkobject {
38662 PyObject_HEAD
38663 swig_globalvar *vars;
38664 } swig_varlinkobject;
38665
38666 SWIGINTERN PyObject *
38667 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38668 return PyString_FromString("<Swig global variables>");
38669 }
38670
38671 SWIGINTERN PyObject *
38672 swig_varlink_str(swig_varlinkobject *v) {
38673 PyObject *str = PyString_FromString("(");
38674 swig_globalvar *var;
38675 for (var = v->vars; var; var=var->next) {
38676 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38677 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38678 }
38679 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38680 return str;
38681 }
38682
38683 SWIGINTERN int
38684 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38685 PyObject *str = swig_varlink_str(v);
38686 fprintf(fp,"Swig global variables ");
38687 fprintf(fp,"%s\n", PyString_AsString(str));
38688 Py_DECREF(str);
38689 return 0;
38690 }
38691
38692 SWIGINTERN void
38693 swig_varlink_dealloc(swig_varlinkobject *v) {
38694 swig_globalvar *var = v->vars;
38695 while (var) {
38696 swig_globalvar *n = var->next;
38697 free(var->name);
38698 free(var);
38699 var = n;
38700 }
38701 }
38702
38703 SWIGINTERN PyObject *
38704 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38705 PyObject *res = NULL;
38706 swig_globalvar *var = v->vars;
38707 while (var) {
38708 if (strcmp(var->name,n) == 0) {
38709 res = (*var->get_attr)();
38710 break;
38711 }
38712 var = var->next;
38713 }
38714 if (res == NULL && !PyErr_Occurred()) {
38715 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38716 }
38717 return res;
38718 }
38719
38720 SWIGINTERN int
38721 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38722 int res = 1;
38723 swig_globalvar *var = v->vars;
38724 while (var) {
38725 if (strcmp(var->name,n) == 0) {
38726 res = (*var->set_attr)(p);
38727 break;
38728 }
38729 var = var->next;
38730 }
38731 if (res == 1 && !PyErr_Occurred()) {
38732 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38733 }
38734 return res;
38735 }
38736
38737 SWIGINTERN PyTypeObject*
38738 swig_varlink_type(void) {
38739 static char varlink__doc__[] = "Swig var link object";
38740 static PyTypeObject varlink_type;
38741 static int type_init = 0;
38742 if (!type_init) {
38743 const PyTypeObject tmp
38744 = {
38745 PyObject_HEAD_INIT(NULL)
38746 0, /* Number of items in variable part (ob_size) */
38747 (char *)"swigvarlink", /* Type name (tp_name) */
38748 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38749 0, /* Itemsize (tp_itemsize) */
38750 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38751 (printfunc) swig_varlink_print, /* Print (tp_print) */
38752 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38753 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38754 0, /* tp_compare */
38755 (reprfunc) swig_varlink_repr, /* tp_repr */
38756 0, /* tp_as_number */
38757 0, /* tp_as_sequence */
38758 0, /* tp_as_mapping */
38759 0, /* tp_hash */
38760 0, /* tp_call */
38761 (reprfunc)swig_varlink_str, /* tp_str */
38762 0, /* tp_getattro */
38763 0, /* tp_setattro */
38764 0, /* tp_as_buffer */
38765 0, /* tp_flags */
38766 varlink__doc__, /* tp_doc */
38767 0, /* tp_traverse */
38768 0, /* tp_clear */
38769 0, /* tp_richcompare */
38770 0, /* tp_weaklistoffset */
38771 #if PY_VERSION_HEX >= 0x02020000
38772 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38773 #endif
38774 #if PY_VERSION_HEX >= 0x02030000
38775 0, /* tp_del */
38776 #endif
38777 #ifdef COUNT_ALLOCS
38778 0,0,0,0 /* tp_alloc -> tp_next */
38779 #endif
38780 };
38781 varlink_type = tmp;
38782 varlink_type.ob_type = &PyType_Type;
38783 type_init = 1;
38784 }
38785 return &varlink_type;
38786 }
38787
38788 /* Create a variable linking object for use later */
38789 SWIGINTERN PyObject *
38790 SWIG_Python_newvarlink(void) {
38791 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38792 if (result) {
38793 result->vars = 0;
38794 }
38795 return ((PyObject*) result);
38796 }
38797
38798 SWIGINTERN void
38799 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38800 swig_varlinkobject *v = (swig_varlinkobject *) p;
38801 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38802 if (gv) {
38803 size_t size = strlen(name)+1;
38804 gv->name = (char *)malloc(size);
38805 if (gv->name) {
38806 strncpy(gv->name,name,size);
38807 gv->get_attr = get_attr;
38808 gv->set_attr = set_attr;
38809 gv->next = v->vars;
38810 }
38811 }
38812 v->vars = gv;
38813 }
38814
38815 SWIGINTERN PyObject *
38816 SWIG_globals() {
38817 static PyObject *_SWIG_globals = 0;
38818 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38819 return _SWIG_globals;
38820 }
38821
38822 /* -----------------------------------------------------------------------------
38823 * constants/methods manipulation
38824 * ----------------------------------------------------------------------------- */
38825
38826 /* Install Constants */
38827 SWIGINTERN void
38828 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38829 PyObject *obj = 0;
38830 size_t i;
38831 for (i = 0; constants[i].type; ++i) {
38832 switch(constants[i].type) {
38833 case SWIG_PY_POINTER:
38834 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38835 break;
38836 case SWIG_PY_BINARY:
38837 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38838 break;
38839 default:
38840 obj = 0;
38841 break;
38842 }
38843 if (obj) {
38844 PyDict_SetItemString(d, constants[i].name, obj);
38845 Py_DECREF(obj);
38846 }
38847 }
38848 }
38849
38850 /* -----------------------------------------------------------------------------*/
38851 /* Fix SwigMethods to carry the callback ptrs when needed */
38852 /* -----------------------------------------------------------------------------*/
38853
38854 SWIGINTERN void
38855 SWIG_Python_FixMethods(PyMethodDef *methods,
38856 swig_const_info *const_table,
38857 swig_type_info **types,
38858 swig_type_info **types_initial) {
38859 size_t i;
38860 for (i = 0; methods[i].ml_name; ++i) {
38861 const char *c = methods[i].ml_doc;
38862 if (c && (c = strstr(c, "swig_ptr: "))) {
38863 int j;
38864 swig_const_info *ci = 0;
38865 const char *name = c + 10;
38866 for (j = 0; const_table[j].type; ++j) {
38867 if (strncmp(const_table[j].name, name,
38868 strlen(const_table[j].name)) == 0) {
38869 ci = &(const_table[j]);
38870 break;
38871 }
38872 }
38873 if (ci) {
38874 size_t shift = (ci->ptype) - types;
38875 swig_type_info *ty = types_initial[shift];
38876 size_t ldoc = (c - methods[i].ml_doc);
38877 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38878 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38879 if (ndoc) {
38880 char *buff = ndoc;
38881 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38882 if (ptr) {
38883 strncpy(buff, methods[i].ml_doc, ldoc);
38884 buff += ldoc;
38885 strncpy(buff, "swig_ptr: ", 10);
38886 buff += 10;
38887 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38888 methods[i].ml_doc = ndoc;
38889 }
38890 }
38891 }
38892 }
38893 }
38894 }
38895
38896 #ifdef __cplusplus
38897 }
38898 #endif
38899
38900 /* -----------------------------------------------------------------------------*
38901 * Partial Init method
38902 * -----------------------------------------------------------------------------*/
38903
38904 #ifdef __cplusplus
38905 extern "C"
38906 #endif
38907 SWIGEXPORT void SWIG_init(void) {
38908 PyObject *m, *d;
38909
38910 /* Fix SwigMethods to carry the callback ptrs when needed */
38911 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38912
38913 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38914 d = PyModule_GetDict(m);
38915
38916 SWIG_InitializeModule(0);
38917 SWIG_InstallConstants(d,swig_const_table);
38918
38919
38920 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38921 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38922 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38923 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38924 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38925 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38926 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38927 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38928 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38929 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38930 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38931 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38932 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38933 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38934 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38935 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38936 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38937 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38938 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38939 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38940 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38941 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38942 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38943 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38944 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38945 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38946 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38947 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38948 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38949 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38950 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38951 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38952 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38953 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38954 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38955 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38956 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38957 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38958 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38959 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38960 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38961 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38962 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38963 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38964 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38965 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38966 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38967 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38968 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38969 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38970 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38971 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38972 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38973 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38974 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38975 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38976 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38977 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38978 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38979 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38980 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38981 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38982 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38983 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38984 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38985 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38986 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38987 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38988 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38989 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38990 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38991 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38992 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38993 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38994 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38995 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38996 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38997 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38998 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38999 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
39000 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
39001 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
39002 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
39003 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
39004 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
39005 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
39006 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
39007 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
39008 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
39009 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
39010 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
39011 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
39012 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
39013 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
39014 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
39015 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
39016 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
39017 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
39018 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
39019 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
39020 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
39021 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
39022 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
39023 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
39024 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
39025 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
39026 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
39027 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
39028 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
39029 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
39030 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
39031 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
39032 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
39033 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
39034 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
39035 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
39036 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
39037 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
39038 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
39039 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
39040 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
39041 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
39042 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
39043 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
39044 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
39045 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
39046 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
39047 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
39048 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
39049 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
39050 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
39051 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
39052 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
39053 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
39054 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
39055 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
39056 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
39057
39058 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
39059
39060 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
39061 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
39062 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
39063 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
39064 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
39065 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
39066 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
39067 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
39068 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
39069 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
39070 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
39071 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
39072 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
39073 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
39074 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
39075 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
39076 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
39077 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
39078 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
39079 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
39080 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
39081 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
39082 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
39083 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
39084 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
39085 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
39086 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
39087 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
39088 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
39089 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
39090 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
39091 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
39092 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
39093 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
39094 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
39095 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
39096 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
39097 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
39098 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
39099 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
39100 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
39101 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
39102 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
39103 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
39104 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
39105 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
39106 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
39107 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
39108 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
39109 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
39110 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
39111 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
39112 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
39113
39114 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
39115
39116 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
39117 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
39118 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
39119 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
39120 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
39121 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
39122 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
39123 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
39124 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
39125 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
39126 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
39127 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
39128 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
39129 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
39130 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
39131 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
39132 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
39133 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
39134 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
39135 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
39136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
39137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
39138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
39139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
39140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
39141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
39142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
39143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
39144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
39145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
39146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
39147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
39148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
39149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
39150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39192
39193 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39194
39195 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39196 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39197 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39198 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39199 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39200 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39201 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39202 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39203 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39204 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39205 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39206 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39207 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39208 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39209 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39210 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39211 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39212 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39213 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39214 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39215 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39216 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39217 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39218 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39219 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39220 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39221 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39222 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39223 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39224 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39225 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39226 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39227 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39228 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39229 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39230 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39231 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39232 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39233 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39234 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39235 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39236 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39237 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39238 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39239 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39240 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39241 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39242 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39243 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39244 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39245 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39246 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39247 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39248 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39249 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39250 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39251 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39252 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39253 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39254 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39255 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39256 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39257 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39258 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39259 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39260 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39261 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39262 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39263 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39264 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39265 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39266 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39267 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39268 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39269 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39270 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39271 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39272 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39273 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39274 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39275 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39276 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39277 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39278 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39279 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39280 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39281 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39282 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39283 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39284 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39285 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39286 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39287 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39288 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39289 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39290 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39291 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39292 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39293 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39294 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39295 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39296 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39297 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39298 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39299 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39300 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39301 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39302 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39303 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39304 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39305 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39306 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39307 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39308 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39309 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39310 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39311 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39312 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39313 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39314 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39315 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39316 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39317 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39318 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39319 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39320 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39321 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39322 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39323 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39324 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39325 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39326 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39327 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39328 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39329 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39330 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39331 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39332 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39333 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39334 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39335 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39336 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39337 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39338 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39339 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39340 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39341 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39342 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39343 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39344 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39345 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39346 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39347 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39348 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39349 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39350 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39351 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39352 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39353 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39354 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39355 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39356 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39357 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39358 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39359 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39360 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39361 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39362 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39363 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39364 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39365 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39366 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39367 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39368 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39369 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39370 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39371 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39372 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39373 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39374 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39375 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39376 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39377 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39378 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39379 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39380 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39381 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39382 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39383 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39384 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39385 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39386 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39387 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39388 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39389 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39390 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39391 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39392 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39393 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39394 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39395
39396 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39397 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39398 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39399 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39400
39401 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39402 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39403 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39404 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39405 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39406 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39407 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39408 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39409 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39410 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39411 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39412 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39413 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39414 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39415 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39416 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39417 }
39418
wxWidgets (Impactor)